二级评估算法开发

pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/assess/SecondaryEvaluationController.java

@@ -0,0 +1,42 @@
+package com.njcn.advance.controller.assess;
+
+import com.njcn.advance.pojo.carrycapacity.param.CarryCapacityQueryDataParam;
+import com.njcn.advance.pojo.carrycapacity.vo.CarryCapacityDataVO;
+import com.njcn.advance.service.assess.SecondaryEvaluationService;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+/**
+ * Description:
+ * Date: 2025/06/06  下午 2:43【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+
+@RestController
+@RequestMapping("secondaryEvaluation")
+@Api(tags = "二级评估")
+@RequiredArgsConstructor
+public class SecondaryEvaluationController extends BaseController {
+    private final SecondaryEvaluationService secondaryEvaluationService;
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/evaluation")
+    @ApiOperation("评估-主页面")
+    public HttpResult<Boolean> evaluation(@RequestParam String assessId,@RequestParam("file") MultipartFile file) {
+        String methodDescribe = getMethodDescribe("evaluation");
+        secondaryEvaluationService.evaluation(assessId,file);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS,true , methodDescribe);
+    }
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/SecondaryEvaluationService.java

@@ -0,0 +1,14 @@
+package com.njcn.advance.service.assess;
+
+import org.springframework.web.multipart.MultipartFile;
+
+/**
+ * Description:
+ * Date: 2025/06/06  下午 3:22【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public interface SecondaryEvaluationService {
+    void evaluation(String assessId, MultipartFile file);
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/impl/SecondaryEvaluationServiceImpl.java

@@ -0,0 +1,777 @@
+package com.njcn.advance.service.assess.impl;
+
+import com.njcn.advance.pojo.dto.assess.HarmonicsIAndZDTO;
+import com.njcn.advance.pojo.po.assess.*;
+import com.njcn.advance.service.assess.*;
+import com.njcn.advance.utils.EasyExcelUtil;
+import com.njcn.advance.utils.assess.*;
+import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.device.biz.pojo.po.Overlimit;
+import com.njcn.device.biz.utils.COverlimitUtil;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.math3.complex.Complex;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Description:
+ * Date: 2025/06/06  下午 3:23【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Service
+@RequiredArgsConstructor
+public class SecondaryEvaluationServiceImpl implements SecondaryEvaluationService {
+
+    private final IAssessLoadParamService iAssessLoadParamService;
+    private final IAssessDicHarmonicCharacterService iAssessDicHarmonicCharacterService;
+    private final  DicDataFeignClient dicDataFeignClient;
+    private final IAssessDicTransformerService iAssessDicTransformerService;
+    private final IAssessTransformerParamService iAssessTransformerParamService;
+
+    private final IAssessCapacitorParamService iAssessCapacitorParamService;
+    private final IAssessUserService iAssessUserService;
+    private final IAssessDicCableTypeService iAssessDicCableTypeService;
+    private final IAssessResultService iAssessResultService;
+    private final IAssessResultAdditionService iAssessResultAdditionService;
+    private final IAssessOverlimitService iAssessOverlimitService;
+    private final IAssessShockLoadParamService iAssessShockLoadParamService;
+    private final IAssessDicShockLoadService iAssessDicShockLoadService;
+
+    private final IAssessWindLoadParamService iAssessWindLoadParamService;
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void evaluation(String assessId, MultipartFile file) {
+        //解析文件取CP95值 2-50次谐波电流含有率，电压含有率，负序电流，三项不平衡度，A,B,C三项最大；
+
+        List<Double> iMax ;
+        Double unbalance;
+        List<Double> uMax;
+        Double iNeg;
+        try {
+            List<Map<Integer, String>> maps = EasyExcelUtil.syncRead(file.getInputStream(), 0, 0);
+            //电流含有率
+            List<Map<Integer, String>> maps1 = maps.subList(3, 52);
+            //负序电流
+            List<Map<Integer, String>> maps2 = maps.subList(52, 53);
+            //电压含有率
+            List<Map<Integer, String>> maps3 = maps.subList(56, 105);
+            //三项不平衡度
+            List<Map<Integer, String>> maps4 = maps.subList(105, 106);
+
+            iMax = maps1.stream().map(temp -> {
+                double a = Double.valueOf(temp.get(5));
+                double b = Double.valueOf(temp.get(10));
+                double c = Double.valueOf(temp.get(15));
+                double v = a > b ? a : b;
+                double max = v > c ? v : c;
+                return max;
+
+            }).collect(Collectors.toList());
+            iNeg = maps2.stream().map(temp -> {
+                double a = Double.valueOf(temp.get(5));
+                double b = Double.valueOf(temp.get(10));
+                double c = Double.valueOf(temp.get(15));
+                double v = a > b ? a : b;
+                double max = v > c ? v : c;
+                return max;
+
+            }).findFirst().get();
+
+            uMax = maps3.stream().map(temp -> {
+                double a = Double.valueOf(temp.get(5));
+                double b = Double.valueOf(temp.get(10));
+                double c = Double.valueOf(temp.get(15));
+                double v = a > b ? a : b;
+                double max = v > c ? v : c;
+                return max;
+
+            }).collect(Collectors.toList());
+
+            unbalance = maps4.stream().map(temp -> {
+                double a = Double.valueOf(temp.get(5));
+                double b = Double.valueOf(temp.get(10));
+                double c = Double.valueOf(temp.get(15));
+                double v = a > b ? a : b;
+                double max = v > c ? v : c;
+                return max;
+
+            }).findFirst().get();
+
+        } catch (Exception e) {
+            throw new BusinessException("解析文件失败，请按模版上传文件");
+
+        }
+        AssessResult assessResult = new AssessResult();
+        AssessResultAddition assessResultAddition = new AssessResultAddition();
+        AssessOverlimit assessOverlimit = new AssessOverlimit();
+        //取出电压字典
+        List<DictData> dictDataList = dicDataFeignClient.getDicDataByTypeName (DicDataTypeEnum.DEV_VOLTAGE_STAND.getName ( )).getData ( );
+        /*************************************谐波评估算法**********************************/
+
+        // 1. 计算单个负荷谐波阻抗和谐波电流
+        //2. 计算配变谐波阻抗 并叠加
+
+        List<HarmonicsIAndZDTO> loadList = new ArrayList<>();
+
+        List<AssessLoadParam> assessLoadParamLista = iAssessLoadParamService.lambdaQuery().eq(AssessLoadParam::getAssessId, assessId).list();
+        if(CollectionUtils.isEmpty(assessLoadParamLista)){
+            throw new BusinessException("评估用户负荷参数缺失");
+        }else {
+            assessLoadParamLista.forEach(temp->{
+                HarmonicsIAndZDTO zuphAndi =new HarmonicsIAndZDTO();
+                String harmId = temp.getHarmId();
+                AssessDicHarmonicCharacter byId = iAssessDicHarmonicCharacterService.getById(harmId);
+                Double[] harmDict = changeAssessDicHarmonicCharacter(byId);
+                Double uln = getVoltage(temp.getLinevoltageScale(), dictDataList);
+                Double pln = getVoltage(temp.getTranslowScale(), dictDataList);
+                Double uKr = temp.getTransImpedance().doubleValue();
+                double sRt = temp.getTranshighCapacity().doubleValue();
+                double pl = temp.getNonlinearloadPower().doubleValue();
+                Double pf = temp.getPowerFactor().doubleValue();
+                //1. 计算单个负荷谐波阻抗和谐波电流
+                HarmonicsIAndZDTO zln = PowerQualityAlgorithmUtil.loadharmonicsCal(uln, pln, pl, pf, harmDict);
+                //2. 计算配变谐波阻抗 并叠加
+                HarmonicsIAndZDTO zph = PowerQualityAlgorithmUtil.transZCal(sRt, pln, uKr, 0.0);
+                Complex[] zuph = new Complex[49];
+                for (int i = 0; i < 49; i++) {
+                    Complex complex = zln.getZ()[i];
+                    Complex complex2 = zph.getZ()[i];
+                    zuph[i] = complex.add(complex2).multiply(uln*uln/(pln*pln));
+                }
+                zuphAndi.setI(zln.getI());
+                zuphAndi.setZ(zuph);
+                loadList.add(zuphAndi);
+            });
+        }
+        // 3. 各负荷并联叠加
+        HarmonicsIAndZDTO loadIAndZDTO = PowerQualityAlgorithmUtil.loadShunt(loadList);
+
+
+        // 4. 变压器谐波阻抗串联叠加
+        HarmonicsIAndZDTO transIAndZDTO = null;
+        Double transUl = null;
+        Double transUh = null;
+        AssessDicTransformer assessDicTransformer = new AssessDicTransformer();
+        AssessTransformerParam assessTransformerParam = iAssessTransformerParamService.lambdaQuery().eq(AssessTransformerParam::getAssessId, assessId).one();
+        if(Objects.nonNull(assessTransformerParam)){
+            assessDicTransformer = iAssessDicTransformerService.lambdaQuery().eq(AssessDicTransformer::getTranstypeId, assessTransformerParam.getTranstypeId()).one();
+            transUl = getVoltage(assessDicTransformer.getTranslowScale(), dictDataList);
+            transUh = getVoltage(assessDicTransformer.getTranshighScale(), dictDataList);
+            Double sRt = assessDicTransformer.getTransCapa().doubleValue();
+            Double uKr =  assessDicTransformer.getShortCircuitImpedance().doubleValue();
+            Double pKrt = assessDicTransformer.getLoadLoss().doubleValue();
+            transIAndZDTO = PowerQualityAlgorithmUtil.transZCal(sRt, transUl, uKr, pKrt);
+        }
+
+        // 5. 电容器组阻抗串联叠加
+        AssessCapacitorParam assessCapacitorParam = iAssessCapacitorParamService.lambdaQuery().eq(AssessCapacitorParam::getAssessId, assessId).one();
+        HarmonicsIAndZDTO capIAndZDTO ;
+        if(Objects.isNull(assessTransformerParam)){
+            throw new BusinessException("评估用户电容器参数缺失");
+        }else {
+
+            Integer capacitorNum = assessCapacitorParam.getCapacitorNum();
+            double capacitorCapacity = assessCapacitorParam.getCapacitorCapacity().doubleValue();
+            double capacitorReactance = assessCapacitorParam.getCapacitorReactance().doubleValue();
+            double capacitorScale =  getVoltage(assessCapacitorParam.getCapacitorScale(), dictDataList);
+
+
+            capIAndZDTO = PowerQualityAlgorithmUtil.capacitorZCal(capacitorScale, capacitorCapacity, capacitorReactance, capacitorNum);
+        }
+
+        // 6. 输电线路阻抗串联叠加
+        AssessUser assessUser = iAssessUserService.lambdaQuery().eq(AssessUser::getAssessId, assessId).one();
+        Double userScale = getVoltage(assessUser.getUserScale(), dictDataList);
+        AssessDicCableType assessDicCableType = iAssessDicCableTypeService.lambdaQuery().eq(AssessDicCableType::getLinetypeId, assessUser.getLinetypeId()).one();
+        Double r1=assessDicCableType.getPosR1().doubleValue();
+        Double x1=assessDicCableType.getPosX1().doubleValue();
+        Double lineLen=assessUser.getLineLen().doubleValue();
+        HarmonicsIAndZDTO lineIAndZDTO = PowerQualityAlgorithmUtil.lineZCal(r1, x1, lineLen);
+
+        // 7. 背景谐波阻抗串联叠加
+        Double un = getVoltage(assessUser.getBusScale(), dictDataList);
+        Double scc = assessUser.getMinshortcircuitCapacity().doubleValue();
+        HarmonicsIAndZDTO bHarmIAndZDTO = PowerQualityAlgorithmUtil.bHarmonicCal(un, scc);
+        // 8. 谐波电压计算
+        //叠加主变压器,电容器, 输电线路,背景谐波阻
+        //有电容器
+        Complex[] zcph = new Complex[49];
+        Double[] ipch = new Double[49];
+        Double[] upch = new Double[49];
+        //无电容器
+        Complex[] zph = new Complex[49];
+        Double[] iph = new Double[49];
+        Double[] uph = new Double[49];
+
+
+
+        if(Objects.nonNull(assessTransformerParam)){
+            Double m = transUh/transUl;
+            for (int h = 0; h < 49; h++) {
+                zcph[h] = loadIAndZDTO.getZ()[h].add(transIAndZDTO.getZ()[h]).multiply(m*m)
+                        .add(capIAndZDTO.getZ()[h])
+                        .add(lineIAndZDTO.getZ()[h])
+                        .add(bHarmIAndZDTO.getZ()[h]);
+
+                zph[h] = loadIAndZDTO.getZ()[h].add(transIAndZDTO.getZ()[h]).multiply(m*m)
+                        .add(lineIAndZDTO.getZ()[h])
+                        .add(bHarmIAndZDTO.getZ()[h]);
+                ipch[h] = (loadIAndZDTO.getI()[h]/m)*(dMod(loadIAndZDTO.getZ()[h].divide(zcph[h])));
+                iph[h] =(loadIAndZDTO.getI()[h]/m)*(dMod(loadIAndZDTO.getZ()[h].divide(zph[h])));
+
+                upch[h] = ipch[h] * dMod(zcph[h])/1000;
+                uph[h] = iph[h] * dMod(zph[h])/1000;
+            }
+        }else {
+            for (int h = 0; h < 49; h++) {
+                zcph[h] = loadIAndZDTO.getZ()[h].add(capIAndZDTO.getZ()[h])
+                        .add(lineIAndZDTO.getZ()[h])
+                        .add(bHarmIAndZDTO.getZ()[h]);
+                zph[h] = loadIAndZDTO.getZ()[h]
+                        .add(lineIAndZDTO.getZ()[h])
+                        .add(bHarmIAndZDTO.getZ()[h]);
+
+                ipch[h] = loadIAndZDTO.getI()[h]*(dMod(loadIAndZDTO.getZ()[h].divide(zcph[h])));
+                iph[h] =loadIAndZDTO.getI()[h]*(dMod(loadIAndZDTO.getZ()[h].divide(zph[h])));
+
+                upch[h] = ipch[h] * dMod(zcph[h])/1000;
+                uph[h] = iph[h] * dMod(zph[h])/1000;
+            }
+
+        }
+
+        // 9. 谐波电流叠加（背景谐波） // 10. 谐波电压叠加（背景谐波）
+        Double[] ich = new Double[49];
+        Double[] ih = new Double[49];
+
+        Double[] urch = new Double[49];
+        Double[] urh = new Double[49];
+
+        for (int h = 0; h < 49; h++) {
+            ich[h] = Math.sqrt(ipch[h]*ipch[h] +iMax.get(h)*iMax.get(h) +PowerQualityAlgorithmUtil.getK(h)*ipch[h]*iMax.get(h));
+            ih[h] = Math.sqrt(iph[h]*iph[h] +iMax.get(h)*iMax.get(h) +PowerQualityAlgorithmUtil.getK(h)*iph[h]*iMax.get(h));
+
+            urch[h] = Math.sqrt(upch[h]*upch[h] +uMax.get(h)*uMax.get(h) +PowerQualityAlgorithmUtil.getK(h)*upch[h]*uMax.get(h))*100*1.732/userScale;
+            urh[h] = Math.sqrt(uph[h]*uph[h] +uMax.get(h)*uMax.get(h) +PowerQualityAlgorithmUtil.getK(h)*uph[h]*uMax.get(h))*100*1.732/userScale;
+
+
+        }
+        //限值计算
+        Overlimit overlimit = COverlimitUtil.globalAssemble(un.floatValue(),
+                assessUser.getAgreedCapacity().floatValue(),
+                assessUser.getPowersupplyCapacity().floatValue(),
+                assessUser.getMinshortcircuitCapacity().floatValue(), 1, 0);
+
+
+        /************************************电压波动算法**********************************/
+        //非风电场取冲击负荷最大的哪个
+        List<AssessShockLoadParam> assessShockLoadParams = iAssessShockLoadParamService.lambdaQuery().eq(AssessShockLoadParam::getAssessId, assessId).list();
+        assessShockLoadParams.forEach(temp->{
+            AssessDicShockLoad byId = iAssessDicShockLoadService.getById(temp.getInpactloadtypeId());
+            if(Objects.isNull(byId)){
+                throw new BusinessException("冲击负荷字典缺失");
+            }
+            temp.setInpactloadMultiple(byId.getInpactloadMultiple());
+        });
+        AssessShockLoadParam assessShockLoadParam = assessShockLoadParams.stream().max(Comparator.comparing(e -> e.getInpactloadMultiple().multiply(e.getInpactloadPower()).doubleValue())).get();
+
+        String isWindfarm = assessUser.getIsWindfarm();
+        Double dMax;
+        if(Objects.equals(isWindfarm,"01")){
+            //风电场
+            dMax = VoltageFluctuationUtil.calculateWindFarmVoltageFluctuation(0.95,
+                    assessUser.getWindfarmCapacity().doubleValue(),
+                    assessUser.getLineGridresistance().doubleValue(),
+                    assessUser.getLineGridreactance().doubleValue(),
+                    un.doubleValue(),
+                    true);
+        }else if(Objects.equals(isWindfarm,"02")){
+            //光伏
+            dMax = VoltageFluctuationUtil.calculateWindFarmVoltageFluctuation(0.95,
+                    assessUser.getWindfarmCapacity().doubleValue(),
+                    assessUser.getLineGridresistance().doubleValue(),
+                    assessUser.getLineGridreactance().doubleValue(),
+                    un.doubleValue(),
+                    false);
+        }else if(Objects.equals(isWindfarm,"03")){
+
+            dMax = VoltageFluctuationUtil.calculateImpactLoadVoltageFluctuation(assessShockLoadParam.getInpactloadPower().doubleValue(),
+                    assessShockLoadParam.getInpactloadMultiple().doubleValue(), scc);
+        }else{
+           throw new BusinessException("用户负荷类型不正确");
+        }
+        double dmaxLimit = VoltageFluctuationUtil.getVoltageFluctuationLimit(un.doubleValue(), assessShockLoadParam.getInpactloadFreq());
+
+        /************************************电压闪变算法**********************************/
+        Double plt;
+        if(Objects.equals(isWindfarm,"01")){
+            List<AssessWindLoadParam> assessWindLoadParams = iAssessWindLoadParamService.lambdaQuery().eq(AssessWindLoadParam::getAssessId, assessId).list();
+            List<VoltageFlickerUtil.WindFarmLoads> windFarmLoadsList = assessWindLoadParams.stream().map(temp -> {
+                VoltageFlickerUtil.WindFarmLoads windFarmLoads = new VoltageFlickerUtil.WindFarmLoads();
+                windFarmLoads.setFlickerCoefficient(temp.getFlickerCoeff().doubleValue());
+                return windFarmLoads;
+            }).collect(Collectors.toList());
+            plt = VoltageFlickerUtil.calculateWindFarmFlicker(scc,windFarmLoadsList);
+        }else {
+            plt = VoltageFlickerUtil.calculateNonWindFarmFlicker(0.30, dMax);
+        }
+        double flickerLimit = VoltageFlickerUtil.getFlickerLimit(un);
+
+        /************************************电压偏差算法**********************************/
+        Double transformerNoLoadCurrent,transformerShortCircuitVoltage,transformerRatedCapacity;
+        if(Objects.nonNull(assessTransformerParam)){
+            transformerNoLoadCurrent = assessDicTransformer.getNoloadCur().doubleValue();
+            transformerShortCircuitVoltage = assessDicTransformer.getShortCircuitImpedance().doubleValue();
+            transformerRatedCapacity = assessDicTransformer.getTransCapa().doubleValue();
+        }  else {
+            transformerNoLoadCurrent = 0.0;
+            transformerShortCircuitVoltage = 0.0;
+            transformerRatedCapacity = 1.0;
+        }
+        //用户投入，100% ，电网高峰
+        double capOnH100Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, true, 1.0);
+        //用户投入，60%，，电网高峰
+        double capOnH60Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, true, 0.6);
+        //用户投入，0% ，电网高峰
+        double capOnH0Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, true, 0);
+
+        //用户未投入，100% ，电网高峰
+        double capOffH100Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, false, 1.0);
+
+        //用户未投入，60%，，电网高峰
+        double capOffH60Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, false, 0.6);
+
+        //用户未投入，0%三个档估算 ，电网高峰
+        double capOffH0Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.65, false, 0);
+
+        //用户投入，100% ，电网低谷
+        double capOnL100Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, true, 1.0);
+
+        //用户投入，60%，电网低谷
+        double capOnL60Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, true, 0.6);
+
+        //用户投入，0%电网低谷
+        double capOnL0Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, true, 0);
+
+
+        //用户未投入，100% ，电网低谷
+        double capOffL100Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, false, 1.0);
+
+        //用户未投入，60% ，电网低谷
+        double capOffL65Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, false, 0.6);
+
+        //用户未投入，0% ，电网低谷
+        double capOffL0Deltav = VoltageDeviationUtil.calculateVoltageDeviation(0.95, scc
+                , assessCapacitorParam.getCapacitorCapacity().doubleValue(), assessUser.getPowersupplyCapacity().doubleValue(),
+                assessUser.getWindfarmCapacity().doubleValue(), transformerNoLoadCurrent,
+                transformerShortCircuitVoltage, transformerRatedCapacity, 0.15, false, 0);
+
+        //限值
+        VoltageDeviationUtil.VoltageDeviationLimits voltageDeviationLimits = VoltageDeviationUtil.getVoltageDeviationLimits(un);
+
+        /************************************三相电压不平衡算法**********************************/
+        //严格估算
+        double accurUnblance = ThreePhaseUnbalanceUtil.calculateVoltageUnbalance(scc, assessUser.getPowersupplyCapacity().floatValue(),
+                un, Objects.equals(assessUser.getSingleLoad(), "00"), iNeg, unbalance, true);
+        //一般估算
+        double approUnblance = ThreePhaseUnbalanceUtil.calculateVoltageUnbalance(scc, assessUser.getPowersupplyCapacity().floatValue(),
+                un, Objects.equals(assessUser.getSingleLoad(), "00"), iNeg, unbalance, true);
+
+        //限值
+        double voltageUnbalanceLimit = ThreePhaseUnbalanceUtil.getVoltageUnbalanceLimit();
+        //组装结果
+        assessResult = assembleRsult(assessResult,assessId,
+                ih,
+                urh,
+                dMax,
+                plt,
+                capOnH100Deltav,
+                capOnH60Deltav,
+                capOnH0Deltav,
+                capOffH100Deltav,
+                capOffH60Deltav,
+                capOffH0Deltav,
+                capOnL100Deltav,
+                capOnL60Deltav,
+                capOnL0Deltav,
+                capOffL100Deltav,
+                capOffL65Deltav,
+                capOffL0Deltav,
+                accurUnblance,
+                approUnblance);
+        assessResultAddition = assembleRsultAddition(assessResultAddition,assessId,ich,urch,plt);
+        assessOverlimit = assembleOverlimit(assessOverlimit,assessId,overlimit,dmaxLimit,flickerLimit,voltageDeviationLimits,voltageUnbalanceLimit);
+
+        iAssessResultService.saveOrUpdate(assessResult);
+        iAssessResultAdditionService.saveOrUpdate(assessResultAddition);
+        iAssessOverlimitService.saveOrUpdate(assessOverlimit);
+    }
+
+    private AssessOverlimit assembleOverlimit(AssessOverlimit assessOverlimit, String assessId, Overlimit overlimit, double dmaxLimit, double flickerLimit, VoltageDeviationUtil.VoltageDeviationLimits voltageDeviationLimits, double voltageUnbalanceLimit) {
+        assessOverlimit.setAssessId(assessId);
+        assessOverlimit.setVodd(BigDecimal.valueOf(overlimit.getUharm3()).setScale(3, RoundingMode.HALF_UP));
+        assessOverlimit.setVevent(BigDecimal.valueOf(overlimit.getUharm2()).setScale(3, RoundingMode.HALF_UP));
+        assessOverlimit.setI2((BigDecimal.valueOf(overlimit.getIharm2()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI3((BigDecimal.valueOf(overlimit.getIharm3()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI4((BigDecimal.valueOf(overlimit.getIharm4()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI5((BigDecimal.valueOf(overlimit.getIharm5()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI6((BigDecimal.valueOf(overlimit.getIharm6()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI7((BigDecimal.valueOf(overlimit.getIharm7()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI8((BigDecimal.valueOf(overlimit.getIharm8()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI9((BigDecimal.valueOf(overlimit.getIharm9()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI10((BigDecimal.valueOf(overlimit.getIharm10()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI11((BigDecimal.valueOf(overlimit.getIharm11()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI12((BigDecimal.valueOf(overlimit.getIharm12()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI13((BigDecimal.valueOf(overlimit.getIharm13()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI14((BigDecimal.valueOf(overlimit.getIharm14()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI15((BigDecimal.valueOf(overlimit.getIharm15()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI16((BigDecimal.valueOf(overlimit.getIharm16()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI17((BigDecimal.valueOf(overlimit.getIharm17()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI18((BigDecimal.valueOf(overlimit.getIharm18()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI19((BigDecimal.valueOf(overlimit.getIharm19()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI20((BigDecimal.valueOf(overlimit.getIharm20()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI21((BigDecimal.valueOf(overlimit.getIharm21()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI22((BigDecimal.valueOf(overlimit.getIharm22()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI23((BigDecimal.valueOf(overlimit.getIharm23()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI24((BigDecimal.valueOf(overlimit.getIharm24()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI25((BigDecimal.valueOf(overlimit.getIharm25()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI26((BigDecimal.valueOf(overlimit.getIharm26()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI27((BigDecimal.valueOf(overlimit.getIharm27()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI28((BigDecimal.valueOf(overlimit.getIharm28()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI29((BigDecimal.valueOf(overlimit.getIharm29()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI30((BigDecimal.valueOf(overlimit.getIharm30()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI31((BigDecimal.valueOf(overlimit.getIharm31()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI32((BigDecimal.valueOf(overlimit.getIharm32()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI33((BigDecimal.valueOf(overlimit.getIharm33()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI34((BigDecimal.valueOf(overlimit.getIharm34()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI35((BigDecimal.valueOf(overlimit.getIharm35()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI36((BigDecimal.valueOf(overlimit.getIharm36()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI37((BigDecimal.valueOf(overlimit.getIharm37()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI38((BigDecimal.valueOf(overlimit.getIharm38()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI39((BigDecimal.valueOf(overlimit.getIharm39()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI40((BigDecimal.valueOf(overlimit.getIharm40()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI41((BigDecimal.valueOf(overlimit.getIharm41()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI42((BigDecimal.valueOf(overlimit.getIharm42()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI43((BigDecimal.valueOf(overlimit.getIharm43()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI44((BigDecimal.valueOf(overlimit.getIharm44()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI45((BigDecimal.valueOf(overlimit.getIharm45()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI46((BigDecimal.valueOf(overlimit.getIharm46()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI47((BigDecimal.valueOf(overlimit.getIharm47()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI48((BigDecimal.valueOf(overlimit.getIharm48()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI49((BigDecimal.valueOf(overlimit.getIharm49()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setI50((BigDecimal.valueOf(overlimit.getIharm50()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setPlt((BigDecimal.valueOf(flickerLimit).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setFluc((BigDecimal.valueOf(dmaxLimit).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setDltavUp((BigDecimal.valueOf(voltageDeviationLimits.getUpperLimit()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setDltavDown((BigDecimal.valueOf(voltageDeviationLimits.getLowerLimit()).setScale(3, RoundingMode.HALF_UP)));
+        assessOverlimit.setUnblance((BigDecimal.valueOf(voltageUnbalanceLimit).setScale(3, RoundingMode.HALF_UP)));
+
+        
+        return assessOverlimit;
+    }
+
+    private AssessResultAddition assembleRsultAddition(AssessResultAddition assessResultAddition,String assessId, Double[] ich, Double[] urch, Double plt) {
+        assessResultAddition.setAssessId(assessId);
+        assessResultAddition.setDateTime(LocalDateTime.now());
+        assessResultAddition.setV2(BigDecimal.valueOf(urch[0]).setScale(3, RoundingMode.HALF_UP));
+        assessResultAddition.setV3(BigDecimal.valueOf(urch[1]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV4(BigDecimal.valueOf(urch[2]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV5(BigDecimal.valueOf(urch[3]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV6(BigDecimal.valueOf(urch[4]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV7(BigDecimal.valueOf(urch[5]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV8(BigDecimal.valueOf(urch[6]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV9(BigDecimal.valueOf(urch[7]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV10(BigDecimal.valueOf(urch[8]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV11(BigDecimal.valueOf(urch[9]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV12(BigDecimal.valueOf(urch[10]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV13(BigDecimal.valueOf(urch[11]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV14(BigDecimal.valueOf(urch[12]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV15(BigDecimal.valueOf(urch[13]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV16(BigDecimal.valueOf(urch[14]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV17(BigDecimal.valueOf(urch[15]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV18(BigDecimal.valueOf(urch[16]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV19(BigDecimal.valueOf(urch[17]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV20(BigDecimal.valueOf(urch[18]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV21(BigDecimal.valueOf(urch[19]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV22(BigDecimal.valueOf(urch[20]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV23(BigDecimal.valueOf(urch[21]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV24(BigDecimal.valueOf(urch[22]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV25(BigDecimal.valueOf(urch[23]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV26(BigDecimal.valueOf(urch[24]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV27(BigDecimal.valueOf(urch[25]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV28(BigDecimal.valueOf(urch[26]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV29(BigDecimal.valueOf(urch[27]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV30(BigDecimal.valueOf(urch[28]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV31(BigDecimal.valueOf(urch[29]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV32(BigDecimal.valueOf(urch[30]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV33(BigDecimal.valueOf(urch[31]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV34(BigDecimal.valueOf(urch[32]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV35(BigDecimal.valueOf(urch[33]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV36(BigDecimal.valueOf(urch[34]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV37(BigDecimal.valueOf(urch[35]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV38(BigDecimal.valueOf(urch[36]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV39(BigDecimal.valueOf(urch[37]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV40(BigDecimal.valueOf(urch[38]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV41(BigDecimal.valueOf(urch[39]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV42(BigDecimal.valueOf(urch[40]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV43(BigDecimal.valueOf(urch[41]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV44(BigDecimal.valueOf(urch[42]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV45(BigDecimal.valueOf(urch[43]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV46(BigDecimal.valueOf(urch[44]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV47(BigDecimal.valueOf(urch[45]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV48(BigDecimal.valueOf(urch[46]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV49(BigDecimal.valueOf(urch[47]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setV50(BigDecimal.valueOf(urch[48]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI2(BigDecimal.valueOf(ich[0]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI3(BigDecimal.valueOf(ich[1]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI4(BigDecimal.valueOf(ich[2]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI5(BigDecimal.valueOf(ich[3]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI6(BigDecimal.valueOf(ich[4]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI7(BigDecimal.valueOf(ich[5]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI8(BigDecimal.valueOf(ich[6]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI9(BigDecimal.valueOf(ich[7]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI10(BigDecimal.valueOf(ich[8]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI11(BigDecimal.valueOf(ich[9]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI12(BigDecimal.valueOf(ich[10]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI13(BigDecimal.valueOf(ich[11]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI14(BigDecimal.valueOf(ich[12]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI15(BigDecimal.valueOf(ich[13]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI16(BigDecimal.valueOf(ich[14]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI17(BigDecimal.valueOf(ich[15]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI18(BigDecimal.valueOf(ich[16]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI19(BigDecimal.valueOf(ich[17]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI20(BigDecimal.valueOf(ich[18]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI21(BigDecimal.valueOf(ich[19]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI22(BigDecimal.valueOf(ich[20]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI23(BigDecimal.valueOf(ich[21]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI24(BigDecimal.valueOf(ich[22]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI25(BigDecimal.valueOf(ich[23]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI26(BigDecimal.valueOf(ich[24]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI27(BigDecimal.valueOf(ich[25]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI28(BigDecimal.valueOf(ich[26]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI29(BigDecimal.valueOf(ich[27]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI30(BigDecimal.valueOf(ich[28]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI31(BigDecimal.valueOf(ich[29]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI32(BigDecimal.valueOf(ich[30]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI33(BigDecimal.valueOf(ich[31]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI34(BigDecimal.valueOf(ich[32]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI35(BigDecimal.valueOf(ich[33]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI36(BigDecimal.valueOf(ich[34]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI37(BigDecimal.valueOf(ich[35]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI38(BigDecimal.valueOf(ich[36]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI39(BigDecimal.valueOf(ich[37]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI40(BigDecimal.valueOf(ich[38]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI41(BigDecimal.valueOf(ich[39]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI42(BigDecimal.valueOf(ich[40]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI43(BigDecimal.valueOf(ich[41]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI44(BigDecimal.valueOf(ich[42]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI45(BigDecimal.valueOf(ich[43]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI46(BigDecimal.valueOf(ich[44]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI47(BigDecimal.valueOf(ich[45]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI48(BigDecimal.valueOf(ich[46]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI49(BigDecimal.valueOf(ich[47]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setI50(BigDecimal.valueOf(ich[48]).setScale(3,RoundingMode.HALF_UP));
+        assessResultAddition.setPlt(BigDecimal.valueOf(plt).setScale(3,RoundingMode.HALF_UP));
+
+
+        return assessResultAddition;
+    }
+
+    private AssessResult assembleRsult(AssessResult assessResult,String assessId, Double[] ih, Double[] urh, Double dMax, Double plt, double capOnH100Deltav, double capOnH60Deltav, double capOnH0Deltav, double capOffH100Deltav, double capOffH60Deltav, double capOffH0Deltav, double capOnL100Deltav, double capOnL60Deltav, double capOnL0Deltav, double capOffL100Deltav, double capOffL65Deltav, double capOffL0Deltav, double accurUnblance, double approUnblance) {
+        assessResult.setAssessId(assessId);
+        assessResult.setDateTime(LocalDateTime.now());
+        assessResult.setV2(BigDecimal.valueOf(urh[0]).setScale(3, RoundingMode.HALF_UP));
+        assessResult.setV3(BigDecimal.valueOf(urh[1]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV4(BigDecimal.valueOf(urh[2]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV5(BigDecimal.valueOf(urh[3]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV6(BigDecimal.valueOf(urh[4]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV7(BigDecimal.valueOf(urh[5]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV8(BigDecimal.valueOf(urh[6]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV9(BigDecimal.valueOf(urh[7]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV10(BigDecimal.valueOf(urh[8]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV11(BigDecimal.valueOf(urh[9]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV12(BigDecimal.valueOf(urh[10]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV13(BigDecimal.valueOf(urh[11]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV14(BigDecimal.valueOf(urh[12]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV15(BigDecimal.valueOf(urh[13]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV16(BigDecimal.valueOf(urh[14]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV17(BigDecimal.valueOf(urh[15]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV18(BigDecimal.valueOf(urh[16]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV19(BigDecimal.valueOf(urh[17]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV20(BigDecimal.valueOf(urh[18]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV21(BigDecimal.valueOf(urh[19]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV22(BigDecimal.valueOf(urh[20]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV23(BigDecimal.valueOf(urh[21]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV24(BigDecimal.valueOf(urh[22]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV25(BigDecimal.valueOf(urh[23]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV26(BigDecimal.valueOf(urh[24]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV27(BigDecimal.valueOf(urh[25]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV28(BigDecimal.valueOf(urh[26]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV29(BigDecimal.valueOf(urh[27]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV30(BigDecimal.valueOf(urh[28]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV31(BigDecimal.valueOf(urh[29]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV32(BigDecimal.valueOf(urh[30]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV33(BigDecimal.valueOf(urh[31]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV34(BigDecimal.valueOf(urh[32]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV35(BigDecimal.valueOf(urh[33]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV36(BigDecimal.valueOf(urh[34]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV37(BigDecimal.valueOf(urh[35]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV38(BigDecimal.valueOf(urh[36]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV39(BigDecimal.valueOf(urh[37]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV40(BigDecimal.valueOf(urh[38]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV41(BigDecimal.valueOf(urh[39]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV42(BigDecimal.valueOf(urh[40]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV43(BigDecimal.valueOf(urh[41]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV44(BigDecimal.valueOf(urh[42]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV45(BigDecimal.valueOf(urh[43]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV46(BigDecimal.valueOf(urh[44]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV47(BigDecimal.valueOf(urh[45]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV48(BigDecimal.valueOf(urh[46]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV49(BigDecimal.valueOf(urh[47]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setV50(BigDecimal.valueOf(urh[48]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI2(BigDecimal.valueOf(ih[0]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI3(BigDecimal.valueOf(ih[1]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI4(BigDecimal.valueOf(ih[2]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI5(BigDecimal.valueOf(ih[3]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI6(BigDecimal.valueOf(ih[4]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI7(BigDecimal.valueOf(ih[5]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI8(BigDecimal.valueOf(ih[6]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI9(BigDecimal.valueOf(ih[7]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI10(BigDecimal.valueOf(ih[8]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI11(BigDecimal.valueOf(ih[9]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI12(BigDecimal.valueOf(ih[10]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI13(BigDecimal.valueOf(ih[11]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI14(BigDecimal.valueOf(ih[12]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI15(BigDecimal.valueOf(ih[13]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI16(BigDecimal.valueOf(ih[14]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI17(BigDecimal.valueOf(ih[15]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI18(BigDecimal.valueOf(ih[16]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI19(BigDecimal.valueOf(ih[17]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI20(BigDecimal.valueOf(ih[18]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI21(BigDecimal.valueOf(ih[19]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI22(BigDecimal.valueOf(ih[20]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI23(BigDecimal.valueOf(ih[21]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI24(BigDecimal.valueOf(ih[22]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI25(BigDecimal.valueOf(ih[23]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI26(BigDecimal.valueOf(ih[24]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI27(BigDecimal.valueOf(ih[25]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI28(BigDecimal.valueOf(ih[26]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI29(BigDecimal.valueOf(ih[27]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI30(BigDecimal.valueOf(ih[28]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI31(BigDecimal.valueOf(ih[29]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI32(BigDecimal.valueOf(ih[30]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI33(BigDecimal.valueOf(ih[31]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI34(BigDecimal.valueOf(ih[32]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI35(BigDecimal.valueOf(ih[33]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI36(BigDecimal.valueOf(ih[34]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI37(BigDecimal.valueOf(ih[35]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI38(BigDecimal.valueOf(ih[36]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI39(BigDecimal.valueOf(ih[37]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI40(BigDecimal.valueOf(ih[38]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI41(BigDecimal.valueOf(ih[39]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI42(BigDecimal.valueOf(ih[40]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI43(BigDecimal.valueOf(ih[41]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI44(BigDecimal.valueOf(ih[42]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI45(BigDecimal.valueOf(ih[43]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI46(BigDecimal.valueOf(ih[44]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI47(BigDecimal.valueOf(ih[45]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI48(BigDecimal.valueOf(ih[46]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI49(BigDecimal.valueOf(ih[47]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setI50(BigDecimal.valueOf(ih[48]).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setPlt(BigDecimal.valueOf(plt).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setApproFluc(BigDecimal.valueOf(dMax).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnH100Deltav(BigDecimal.valueOf(capOnH100Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnH60Deltav(BigDecimal.valueOf(capOnH60Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnH0Deltav(BigDecimal.valueOf(capOnH0Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffH100Deltav(BigDecimal.valueOf(capOffH100Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffH60Deltav(BigDecimal.valueOf(capOffH60Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffH0Deltav(BigDecimal.valueOf(capOffH0Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnL100Deltav(BigDecimal.valueOf(capOnL100Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnL60Deltav(BigDecimal.valueOf(capOnL60Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOnL0Deltav(BigDecimal.valueOf(capOnL0Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffL100Deltav(BigDecimal.valueOf(capOffL100Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffL60Deltav(BigDecimal.valueOf(capOffL65Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setCapOffL0Deltav(BigDecimal.valueOf(capOffL0Deltav).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setApproUnblance(BigDecimal.valueOf(approUnblance).setScale(3,RoundingMode.HALF_UP));
+        assessResult.setAccurUnblance(BigDecimal.valueOf(accurUnblance).setScale(3,RoundingMode.HALF_UP));
+
+
+        return assessResult;
+    }
+
+    private Double[] changeAssessDicHarmonicCharacter(AssessDicHarmonicCharacter byId) {
+        Double[] doubles =  new Double[49];
+        for (int h = 0; h < 49; h++) {
+            doubles[h] =((BigDecimal) ReflectUtils.getValue(byId,"i"+(h+2))).doubleValue();
+        }
+        return doubles;
+    }
+    /**
+     * @Description: 根据电压字典获取电压等级
+     * @Param: [id, dictDataList]
+     * @return: java.lang.Double
+     * @Author: clam
+     * @Date: 2023/2/23
+     */
+    private Double getVoltage(String id, List<DictData> dictDataList) {
+        for (DictData dictData : dictDataList) {
+            if (dictData.getId ( ).equals (id)) {
+                Double result = Double.valueOf (dictData.getValue ( ));
+                return result;
+            }
+        }
+        throw new BusinessException("电压等级有误");
+    }
+
+    private double dMod(Complex complex){
+        return Math.sqrt(complex.getReal()*complex.getReal()+complex.getImaginary()*complex.getImaginary());
+    }
+
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/PowerQualityAlgorithmUtil.java

@@ -0,0 +1,184 @@
+package com.njcn.advance.utils.assess;
+
+
+
+import com.njcn.advance.pojo.dto.assess.HarmonicsIAndZDTO;
+import org.apache.commons.math3.complex.Complex;
+
+import java.util.List;
+
+/**
+ * Description:
+ * Date: 2024/8/7  11:08【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class PowerQualityAlgorithmUtil {
+   /**
+   * @Description: loadharmonicsCal
+   * @Param:  uln负荷电压 pf功率因数 pl非线性负荷功率
+   * @return: java.util.List<java.util.List<java.util.List<java.lang.Double>>>
+   * @Author: clam
+   * @Date: 2024/8/15
+   */
+    public static HarmonicsIAndZDTO loadharmonicsCal(Double uln, Double pln, Double pl, Double pf, Double[] harmDict){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Double[] i = new Double[49];
+        Complex[] z = new Complex[49];
+        //①计算负荷视在功率S_L：
+        Double sl = pl/pf;
+        //②计算负荷无功功率Q_L
+        Double ql = Math.sqrt(1-pf*pf)*sl;
+        //③计算负荷基波电流
+        Double il1 = sl/(Math.sqrt(3)*uln);
+
+        //计算低压侧基波电流
+        Double ill1 =sl/(Math.sqrt(3)*pln);
+        //④计算基波阻抗：
+        Complex zl1 = new Complex(pl*1000/(3*ill1*ill1),ql*1000/(3*ill1*ill1));
+        for (int h = 0; h < 49; h++) {
+            i[h] = il1*harmDict[h]/100.00;
+            z[h] = new Complex(Math.sqrt(h+2)*pl*1000/(3*ill1*ill1),(h+2)*ql*1000/(3*ill1*ill1));
+
+        }
+        harmonicsIAndZDTO.setI(i);
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+    /**
+    * @Description: transZCal 变压器谐波阻抗
+    * @Param:  sRt额定容量 uRtl低压侧电压 短路阻抗uKr 负载损耗 pKrt
+    * @return: HarmonicsIAndZDTO
+    * @Author: clam
+    * @Date: 2024/8/15
+    */
+    public static HarmonicsIAndZDTO transZCal(Double sRt, Double uRtl , Double uKr, Double pKrt){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Complex[] z = new Complex[49];
+        //①计算变压器的低压侧的额定电流
+        Double iRt = sRt/(Math.sqrt(3)*uRtl);
+        //计算变压器的基波阻抗
+        Double zT1 = (uKr/100.00) *(uRtl*uRtl*1000.00/sRt);
+        Double rT1 = (pKrt*1000.00)/(3*iRt*iRt);
+        if(zT1<rT1){
+            throw  new RuntimeException("变压器参数存在问题");
+        }
+        Double xT1 = Math.sqrt(zT1*zT1 -rT1*rT1);
+        //③计算变压器的各次阻抗
+        for (int h = 0; h < 49; h++) {
+            z[h] = new Complex(Math.sqrt(h+2)*rT1,(h+2)*xT1);
+        }
+
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+    /**
+    * @Description: capacitorZCal 电容器阻抗
+    * @Param:
+    * @return: HarmonicsIAndZDTO
+    * @Author: clam
+    * @Date: 2024/8/15
+    */
+    public static HarmonicsIAndZDTO capacitorZCal(Double uRc, Double qRc , Double kCl, Integer cNum){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Complex[] z = new Complex[49];
+        //计算不含电抗率的基本的阻抗
+        Double z_b = uRc*uRc*1000/(cNum*qRc);
+        for (int h = 0; h < 49; h++) {
+            if (kCl<=1){
+                z[h] = new Complex(Math.sqrt(h+2)*0.02*z_b,-z_b*((1.00/(h+2))-((h+2)*kCl/100.00)));
+            }else {
+                z[h] = new Complex(0.00,-z_b*((1.00/(h+2))-((h+2)*kCl/100.00)));
+            }
+        }
+
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+    /**
+    * @Description: lineZCal 电路
+    * @Param:
+    * @return: HarmonicsIAndZDTO
+    * @Author: clam
+    * @Date: 2024/8/15
+    */
+    public static HarmonicsIAndZDTO lineZCal(Double r1, Double x1, Double lineLen){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Complex[] z = new Complex[49];
+        //计算不含电抗率的基本的阻抗
+        Complex z_w1 = new Complex(r1*lineLen,x1*lineLen);
+        for (int h = 0; h < 49; h++) {
+           z[h] = new Complex(0.288*r1+0.138*Math.sqrt((h+2)*r1),(h+2)*x1);
+        }
+
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+
+
+    public static HarmonicsIAndZDTO loadShunt(List<HarmonicsIAndZDTO> harmonicsIAndZDTOList){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Double[] i = new Double[50];
+        Complex[] z = new Complex[50];
+        for (int h = 0; h < 49; h++) {
+            int finalH = h;
+            i[h] = harmonicsIAndZDTOList.stream().map(temp->{
+                return  temp.getI()[finalH];
+            }).reduce((a,b)->Math.sqrt(a*a+b*b+getK(finalH))*a*b).get();
+            z[h] = harmonicsIAndZDTOList.stream().map(temp->{
+                return temp.getZ()[finalH].reciprocal();
+            }).reduce((a,b)->a.add(b)).get().reciprocal();
+        }
+
+        harmonicsIAndZDTO.setI(i);
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+    //背景谐波阻抗
+    public static HarmonicsIAndZDTO bHarmonicCal(double un , double ssc){
+        HarmonicsIAndZDTO harmonicsIAndZDTO = new HarmonicsIAndZDTO();
+        Complex[] z = new Complex[49];
+        //计算不含电抗率的基本的阻抗
+        Complex zppc1 = new Complex(0.00,un*un/ssc);
+        for (int h = 0; h < 49; h++) {
+            z[h] = new Complex(0.0,(h+2)*un*un/ssc);
+        }
+
+        harmonicsIAndZDTO.setZ(z);
+        return harmonicsIAndZDTO;
+    }
+    public static double getK(int h) {
+        if(h>13||h==9||h%2==0){
+            return 0.0;
+        } else if (h==3) {
+            return 1.62;
+
+        }
+        else if (h==3) {
+            return 1.62;
+
+        }
+        else if (h==5) {
+            return 1.28;
+
+        }
+        else if (h==7) {
+            return 0.72;
+
+        }
+        else if (h==11) {
+            return 0.18;
+
+        }
+        else if (h==13) {
+            return 0.08;
+
+        }else if (h==1) {
+            return 2.00;
+
+        }
+        return 0.00;
+    }
+
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ReflectUtils.java

@@ -0,0 +1,129 @@
+package com.njcn.advance.utils.assess;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ReflectUtils {
+    /**
+     * 通过字段名从对象或对象的父类中得到字段的值
+     * @param object 对象实例
+     * @param fieldName 字段名
+     * @return 字段对应的值
+     * @throws Exception
+     */
+    public static Object getValue(Object object, String fieldName)  {
+        if (object == null) {
+            return null;
+        }
+        if (StringUtils.isBlank(fieldName)) {
+            return null;
+        }
+        Field field = null;
+        Class<?> clazz = object.getClass();
+        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
+            try {
+                field = clazz.getDeclaredField(fieldName);
+                field.setAccessible(true);
+                return field.get(object);
+            } catch (Exception e) {
+                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
+                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
+            }
+        }
+        return null;
+    }
+
+
+    /**
+     * 通过字段名从对象或对象的父类中得到字段的值（调用字典的get方法）
+     * @param object 对象实例
+     * @param fieldName 字段名
+     * @return 字段对应的值
+     * @throws Exception
+     */
+    public static Object getValueOfGet(Object object, String fieldName) throws Exception {
+        if (object == null) {
+            return null;
+        }
+        if (StringUtils.isBlank(fieldName)) {
+            return null;
+        }
+        Field field = null;
+        Class<?> clazz = object.getClass();
+        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
+            try {
+                field = clazz.getDeclaredField(fieldName);
+                field.setAccessible(true);
+
+                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
+                //获得get方法
+                Method getMethod = pd.getReadMethod();
+                //执行get方法返回一个Object
+                return getMethod.invoke(object);
+            } catch (Exception e) {
+                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
+                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 通过字段名从对象或对象的父类中得到字段的值（调用字典的get方法，可以取出复杂的对象的值）
+     * @param object 对象实例
+     * @param fieldName 字段名
+     * @return 字段对应的值
+     * @throws Exception
+     */
+    public static Object getValueOfGetIncludeObjectFeild(Object object, String fieldName)
+            throws Exception {
+
+        if (object == null) {
+            return null;
+        }
+        if (StringUtils.isBlank(fieldName)) {
+            return null;
+        }
+
+        if(HashMap.class.equals(object.getClass())){
+            return ((Map)object).get(fieldName);
+        }
+
+        Field field = null;
+        Class<?> clazz = object.getClass();
+        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
+            try {
+                if (fieldName.contains(".")) {
+                    // 如：operatorUser.name、operatorUser.org.name，递归调用
+                    String[] splitFiledName = fieldName.split("\\.");
+                    return getValueOfGetIncludeObjectFeild(
+                            getValueOfGetIncludeObjectFeild(object, splitFiledName[0]),
+                            splitFiledName[1]);
+                }
+                field = clazz.getDeclaredField(fieldName);
+                field.setAccessible(true);
+
+                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
+                //获得get方法
+                Method getMethod = pd.getReadMethod();
+                //执行get方法返回一个Object
+                return getMethod.invoke(object);
+            } catch (Exception e) {
+                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
+                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
+            }
+        }
+
+        return null;
+    }
+
+
+
+
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ThreePhaseUnbalanceUtil.java

@@ -0,0 +1,53 @@
+package com.njcn.advance.utils.assess;
+
+/**
+ * Description:
+ * Date: 2025/05/30  下午 3:35【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class ThreePhaseUnbalanceUtil {
+
+    // Calculate three-phase voltage unbalance
+    /** 
+    * @Description: calculateVoltageUnbalance
+    * @Param: 
+
+     * @param pccShortCircuitCapacity 评估用户参数表最小短路容量
+     * @param contractCapacity 评估用户参数表供电设备容量
+     *
+     * @param voltageLevel 评估用户参数表母线电压等级
+     * @param isSinglePhase 评估用户参数表是否为单相负荷
+     * @param negativeSequenceCurrent 负序电流值，导入背景数据时导入
+     * @param ppcThreeVoltage PCC点背景三相电压不平衡，导入背景数据时导入
+     * @param isStrict 是否严格估算
+    * @return: double 
+    * @Author: clam
+    * @Date: 2025/06/06 
+    */ 
+    public static double calculateVoltageUnbalance(
+             double pccShortCircuitCapacity,
+            double contractCapacity,double voltageLevel,boolean isSinglePhase,
+            double negativeSequenceCurrent,double ppcThreeVoltage,Boolean isStrict) {
+        double threeVoltage;
+        if (isSinglePhase) {
+            // For single-phase load
+            threeVoltage = contractCapacity* 100 / pccShortCircuitCapacity ;
+        } else {
+            // For three-phase load
+            threeVoltage =  (Math.sqrt(3) * negativeSequenceCurrent * voltageLevel) * 100/ pccShortCircuitCapacity ;
+        }
+        if(isStrict){
+            return threeVoltage+ppcThreeVoltage;
+        }else{
+            return Math.sqrt(threeVoltage*threeVoltage+ppcThreeVoltage*ppcThreeVoltage);
+        }
+    }
+
+   
+    // Get voltage unbalance limit
+    public static double getVoltageUnbalanceLimit() {
+        return 2.0; // Standard limit is 2%
+    }
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageDeviationUtil.java

@@ -0,0 +1,84 @@
+package com.njcn.advance.utils.assess;
+
+/**
+ * Description:
+ * Date: 2025/05/30  下午 3:34【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class VoltageDeviationUtil {
+
+    // Calculate voltage deviation for various conditions
+    /** 
+    * @Description: calculateVoltageDeviation
+    * @Param: 
+     * @param powerFactor 用户真功率因数默认取0.95
+     * @param pccShortCircuitCapacity 评估用户参数表最小短路容量
+     * @param capacitorCapacity 评估用户电容器组参数表单组容量
+     * @param supplyCapacity 评估用户参数表供电设备容量
+     * @param activeCapacity 评估用户参数表有功容量
+     * @param transformerNoLoadCurrent 变压器字典表空载电流
+     * @param transformerShortCircuitVoltage 变压器字典表短路阻抗
+     * @param transformerRatedCapacity 变压器字典表额定容量
+     * @param loadRate 用户100%，60%，0%三个档估算，系数分别为1.0,0.6,0
+     * @param capacitorInService 电容器是否投入
+     * @param outputPercentage  电网高峰和低谷负荷率，高峰默认为0.65,低谷默认为0.15
+    * @return: double 
+    * @Author: clam
+    * @Date: 2025/06/10 
+    */ 
+    public static double calculateVoltageDeviation(
+            double powerFactor, double pccShortCircuitCapacity,
+            double capacitorCapacity, double supplyCapacity,
+            double activeCapacity,
+            double transformerNoLoadCurrent, double transformerShortCircuitVoltage,
+            double transformerRatedCapacity, double loadRate,
+            boolean capacitorInService, double outputPercentage) {
+
+        // 1. Calculate substation transformer reactive capacity
+        double qk3 = supplyCapacity * Math.sqrt(1 - Math.pow(powerFactor, 2)) * 1000;
+
+        // 2. Calculate user's reactive power absorbed from grid
+        // Transformer reactive loss
+        double qt0 = transformerShortCircuitVoltage * Math.pow(activeCapacity, 2) /
+                (100 * transformerRatedCapacity) +
+                (transformerNoLoadCurrent * transformerRatedCapacity / 100);
+
+        double qu;
+        if (capacitorInService) {
+            qu = activeCapacity * Math.sqrt(1/Math.pow(powerFactor, 2) - 1) * 1000 -
+                    capacitorCapacity + qt0;
+        } else {
+            qu = activeCapacity * Math.sqrt(1/Math.pow(powerFactor, 2) - 1) * 1000 + qt0;
+        }
+
+        // 3. Calculate voltage deviation under each condition
+        return ((qu * outputPercentage + qk3 * loadRate) / pccShortCircuitCapacity )* 0.001;
+    }
+
+    // Get voltage deviation limits
+    public static VoltageDeviationLimits getVoltageDeviationLimits(double voltageLevel) {
+        if (voltageLevel <= 0.38) {
+            return new VoltageDeviationLimits(7.0, -10.0);
+        } else if (voltageLevel <= 20) {
+            return new VoltageDeviationLimits(7.0, -7.0);
+        } else {
+            return new VoltageDeviationLimits(7.0, -3.0);
+        }
+    }
+
+    public static class VoltageDeviationLimits {
+        private final double upperLimit;
+        private final double lowerLimit;
+
+        public VoltageDeviationLimits(double upperLimit, double lowerLimit) {
+            this.upperLimit = upperLimit;
+            this.lowerLimit = lowerLimit;
+        }
+
+        public double getUpperLimit() { return upperLimit; }
+        public double getLowerLimit() { return lowerLimit; }
+    }
+}
+

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFlickerUtil.java

@@ -0,0 +1,46 @@
+package com.njcn.advance.utils.assess;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * Description:
+ * Date: 2025/05/30  下午 3:34【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class VoltageFlickerUtil {
+
+    // Calculate long-term flicker for wind farm
+    public static double calculateWindFarmFlicker(Double ssc,
+            List<WindFarmLoads> windFarmLoadsList) {
+
+        double sum = 0;
+        for (int i = 0; i < windFarmLoadsList.size(); i++) {
+            sum += windFarmLoadsList.get(i).getFlickerCoefficient()*windFarmLoadsList.get(i).getRatedApparentPower();
+        }
+
+        return Math.sqrt(sum)/ssc;
+    }
+
+    // Calculate long-term flicker for non-wind farm loads
+    //flickerCoefficient默认0.3直流电弧炉一般取0.30
+    public static double calculateNonWindFarmFlicker(
+            double voltageFluctuation, double flickerCoefficient) {
+
+        return flickerCoefficient * voltageFluctuation;
+    }
+
+    // Get flicker limit based on voltage level
+    public static double getFlickerLimit(double voltageLevel) {
+        return voltageLevel <= 110 ? 1.0 : 0.8;
+    }
+    //风电场类负荷
+    @Data
+    public static class WindFarmLoads{
+        private Double ratedApparentPower;//风机额定视在功率
+        private Double flickerCoefficient;//风机闪变系数
+    }
+}

pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFluctuationUtil.java

@@ -0,0 +1,87 @@
+package com.njcn.advance.utils.assess;
+
+/**
+ * Description:
+ * Date: 2025/05/30  下午 3:32【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+public class VoltageFluctuationUtil {
+
+    /** 
+    * @Description: calculateWindFarmVoltageFluctuation
+    * @Param: 
+     * @param powerFactor 用户真功率因数，默认取0.95
+     * @param installedCapacity 评估用户参数表风电场装机容量
+     * @param pccResistance 评估用户参数表PCC点电阻分量
+     * @param pccReactance 评估用户参数表PCC点电抗分量
+     * @param voltageLevel 评估用户参数表母线电压等级
+     * @param isPV 是否是风电光伏
+    * @return: double 
+    * @Author: clam
+    * @Date: 2025/06/06 
+    */ 
+    public static double calculateWindFarmVoltageFluctuation(double powerFactor,
+            double installedCapacity,
+            double pccResistance, double pccReactance,double voltageLevel,
+             boolean isPV) {
+
+        // 1. Calculate active power change
+        double deltaP;
+        if (isPV) {
+            // For PV station, take 10% of rated capacity as power increment
+            deltaP = installedCapacity * 0.1;
+        } else {
+            // For wind farm, get deltaP based on installed capacity
+            if (installedCapacity < 30) {
+                deltaP = 10;
+            } else if (installedCapacity <= 150) {
+                deltaP = installedCapacity / 3;
+            } else {
+                deltaP = 50;
+            }
+        }
+
+        // 2. Calculate reactive voltage change rate
+        double deltaQ = (deltaP / powerFactor) * Math.sqrt(1 - Math.pow(powerFactor, 2));
+
+        // 3. Calculate voltage fluctuation
+        return (pccResistance * deltaP + pccReactance * deltaQ) / Math.pow(voltageLevel, 2) * 100;
+    }
+
+    // Calculate voltage fluctuation for non-wind farm loads
+    public static double calculateImpactLoadVoltageFluctuation(
+            double impactLoadCapacity, double startCapacityMultiple,
+            double pccShortCircuitCapacity) {
+
+        // 1. Calculate maximum power change
+        double deltaSmax = impactLoadCapacity * startCapacityMultiple;
+
+        // 2. Calculate voltage fluctuation
+        return (deltaSmax / pccShortCircuitCapacity) * 100;
+    }
+
+    // Get voltage fluctuation limit based on voltage level and frequency
+    public static double getVoltageFluctuationLimit(
+            double voltageLevel, String frequencyCategory) {
+
+        if (voltageLevel <= 35) {
+            // For 1kV < UN ≤ 35kV
+            switch (frequencyCategory) {
+                case "01": return 6.0; // 5%~6%
+                case "02": return 4.0;
+                case "03": return 3.0;
+                default: return 3.0; // For irregular fluctuations like arc furnaces
+            }
+        } else {
+            // For 35kV < UN ≤ 750kV
+            switch (frequencyCategory) {
+                case "01": return 5.0; // 3%~5%
+                case "02": return 3.0;
+                case "03": return 2.5;
+                default: return 2.5; // For irregular fluctuations like arc furnaces
+            }
+        }
+    }
+}