From 314ece3ddddffe8dda9fd9edf2553914fba05dd7 Mon Sep 17 00:00:00 2001 From: hzj <826100833@qq.com> Date: Wed, 11 Jun 2025 13:59:36 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BA=8C=E7=BA=A7=E8=AF=84=E4=BC=B0=E7=AE=97?= =?UTF-8?q?=E6=B3=95=E5=BC=80=E5=8F=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../pojo/dto/assess/HarmonicsIAndZDTO.java | 17 + .../pojo/po/assess/AssessCapacitorParam.java | 3 +- .../pojo/po/assess/AssessDicCableType.java | 3 +- .../po/assess/AssessDicHarmonicCharacter.java | 3 +- .../pojo/po/assess/AssessDicShockLoad.java | 3 +- .../pojo/po/assess/AssessDicTransformer.java | 3 +- .../pojo/po/assess/AssessLoadParam.java | 3 +- .../pojo/po/assess/AssessOverlimit.java | 3 +- .../advance/pojo/po/assess/AssessResult.java | 16 +- .../pojo/po/assess/AssessResultAddition.java | 3 +- .../pojo/po/assess/AssessShockLoadParam.java | 3 +- .../po/assess/AssessTransformerParam.java | 3 +- .../advance/pojo/po/assess/AssessUser.java | 10 +- .../pojo/po/assess/AssessWindLoadParam.java | 4 +- .../com/njcn/advance/utils/EasyExcelUtil.java | 46 +- .../assess/SecondaryEvaluationController.java | 42 + .../assess/SecondaryEvaluationService.java | 14 + .../impl/SecondaryEvaluationServiceImpl.java | 777 ++++++++++++++++++ .../assess/PowerQualityAlgorithmUtil.java | 184 +++++ .../advance/utils/assess/ReflectUtils.java | 129 +++ .../utils/assess/ThreePhaseUnbalanceUtil.java | 53 ++ .../utils/assess/VoltageDeviationUtil.java | 84 ++ .../utils/assess/VoltageFlickerUtil.java | 46 ++ .../utils/assess/VoltageFluctuationUtil.java | 87 ++ 24 files changed, 1505 insertions(+), 34 deletions(-) create mode 100644 pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/dto/assess/HarmonicsIAndZDTO.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/assess/SecondaryEvaluationController.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/SecondaryEvaluationService.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/impl/SecondaryEvaluationServiceImpl.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/PowerQualityAlgorithmUtil.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ReflectUtils.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ThreePhaseUnbalanceUtil.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageDeviationUtil.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFlickerUtil.java create mode 100644 pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFluctuationUtil.java diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/dto/assess/HarmonicsIAndZDTO.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/dto/assess/HarmonicsIAndZDTO.java new file mode 100644 index 000000000..209e87573 --- /dev/null +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/dto/assess/HarmonicsIAndZDTO.java @@ -0,0 +1,17 @@ +package com.njcn.advance.pojo.dto.assess; + +import lombok.Data; +import org.apache.commons.math3.complex.Complex; + +/** + * Description: + * Date: 2024/8/15 15:07【需求编号】 + * + * @author clam + * @version V1.0.0 + */ +@Data +public class HarmonicsIAndZDTO { + private Double[] i; + private Complex[] z; +} diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessCapacitorParam.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessCapacitorParam.java index 63dd9f9dc..31779611c 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessCapacitorParam.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessCapacitorParam.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessCapacitorParam extends BaseEntity implements Serializable { /** * 电容器组ID，例：b2a0ddf21992416f936b572459a3d8f4 */ - @TableId + @TableId(value = "capacitor_id",type = IdType.ASSIGN_UUID) private String capacitorId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicCableType.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicCableType.java index c92044509..275cc639f 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicCableType.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicCableType.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessDicCableType extends BaseEntity implements Serializable { /** * 线路线缆类型ID 例：3491b6cce56141f1a2a0a79a15b0e91e */ - @TableId + @TableId(value = "linetype_id",type = IdType.ASSIGN_UUID) private String linetypeId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicHarmonicCharacter.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicHarmonicCharacter.java index 1c20571b4..92beb2875 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicHarmonicCharacter.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicHarmonicCharacter.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessDicHarmonicCharacter implements Serializable { /** * 谐波源特性字典ID，例：d53f0026d2f04c9e9fee6bba8386487a */ - @TableId + @TableId(value = "harm_id",type = IdType.ASSIGN_UUID) private String harmId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicShockLoad.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicShockLoad.java index 99cfb3097..4efa0ccb6 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicShockLoad.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicShockLoad.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessDicShockLoad extends BaseEntity implements Serializable { /** * 冲击负荷类型ID， 例：d19c10178eeb4da2bca1df18a050524d */ - @TableId + @TableId(value = "INPACTLOADTYPE_ID",type = IdType.ASSIGN_UUID) private String inpactloadtypeId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicTransformer.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicTransformer.java index 437a1ae44..34b23eb4b 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicTransformer.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessDicTransformer.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessDicTransformer extends BaseEntity implements Serializable { /** * 变压器类型ID，例：f401fa4abb71402bb5e9528209ea219e */ - @TableId + @TableId(value = "transtype_id",type = IdType.ASSIGN_UUID) private String transtypeId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessLoadParam.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessLoadParam.java index fe2cb9728..63c7cab0f 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessLoadParam.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessLoadParam.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessLoadParam extends BaseEntity implements Serializable { /** * 用户负荷ID，例：759b793da37548d8b865efdc7f461304 */ - @TableId + @TableId(value = "load_id",type = IdType.ASSIGN_UUID) private String loadId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessOverlimit.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessOverlimit.java index 022edda16..c4ff5d5ba 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessOverlimit.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessOverlimit.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessOverlimit extends BaseEntity implements Serializable { /** * 评估用户ID，例：8afaa9a15707483a0157262f8e78077d */ - @TableId + @TableId(value = "assess_id",type = IdType.ASSIGN_UUID) private String assessId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResult.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResult.java index 5dc48d1d7..a826e3ca5 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResult.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResult.java @@ -1,5 +1,7 @@ package com.njcn.advance.pojo.po.assess; +import com.baomidou.mybatisplus.annotation.IdType; +import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; @@ -27,7 +29,7 @@ public class AssessResult extends BaseEntity implements Serializable { /** * 评估用户ID，例：8afaa9a15707483a0157262f8e78077d */ - @TableId + @TableId(value = "assess_id",type = IdType.ASSIGN_UUID) private String assessId; /** @@ -538,61 +540,73 @@ public class AssessResult extends BaseEntity implements Serializable { /** * 电网高峰电容器投入100%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_h_100_DELTAV") private BigDecimal capOnH100Deltav; /** * 电网高峰电容器投入60%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_h_60_DELTAV") private BigDecimal capOnH60Deltav; /** * 电网高峰电容器投入0%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_h_0_DELTAV") private BigDecimal capOnH0Deltav; /** * 电网高峰电容器未投入100%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_h_100_DELTAV") private BigDecimal capOffH100Deltav; /** * 电网高峰电容器未投入60%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_h_60_DELTAV") private BigDecimal capOffH60Deltav; /** * 电网高峰电容器未投入0%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_h_0_DELTAV") private BigDecimal capOffH0Deltav; /** * 电网低谷电容器投入100%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_l_100_DELTAV") private BigDecimal capOnL100Deltav; /** * 电网低谷电容器投入60%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_l_60_DELTAV") private BigDecimal capOnL60Deltav; /** * 电网低谷电容器投入0%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_ON_l_0_DELTAV") private BigDecimal capOnL0Deltav; /** * 电网低谷电容器未投入100%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_l_100_DELTAV") private BigDecimal capOffL100Deltav; /** * 电网低谷电容器未投入60%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_l_60_DELTAV") private BigDecimal capOffL60Deltav; /** * 电网低谷电容器未投入0%出力电压偏差，例：1.15 */ + @TableField(value = "CAP_OFF_l_0_DELTAV") private BigDecimal capOffL0Deltav; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResultAddition.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResultAddition.java index 9c4399179..3f67bde35 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResultAddition.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessResultAddition.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -27,7 +26,7 @@ public class AssessResultAddition extends BaseEntity implements Serializable { /** * 评估用户ID，例：8afaa9a15707483a0157262f8e78077d */ - @TableId + @TableId(value = "assess_id",type = IdType.ASSIGN_UUID) private String assessId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessShockLoadParam.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessShockLoadParam.java index 86bfb1a13..c04d84511 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessShockLoadParam.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessShockLoadParam.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -26,7 +25,7 @@ public class AssessShockLoadParam extends BaseEntity implements Serializable { /** * 冲击负荷ID，例：ffd5b663906648ad90811a4fcf108fec */ - @TableId + @TableId(value = "inpactload_id",type = IdType.ASSIGN_UUID) private String inpactloadId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessTransformerParam.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessTransformerParam.java index 13d65f791..3797f65f3 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessTransformerParam.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessTransformerParam.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -25,7 +24,7 @@ public class AssessTransformerParam extends BaseEntity implements Serializable /** * 变压器ID，例：8ead7dfa8fc0495a890fef2c847e4fea */ - @TableId + @TableId(value = "trans_id",type = IdType.ASSIGN_UUID) private String transId; /** diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessUser.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessUser.java index c93effff6..bf4762b76 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessUser.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessUser.java @@ -1,17 +1,12 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; import java.math.BigDecimal; - -import io.swagger.annotations.ApiModelProperty; import lombok.Getter; import lombok.Setter; -import javax.validation.constraints.NotBlank; - /** *

* @@ -30,12 +25,9 @@ public class AssessUser extends BaseEntity implements Serializable { /** * 评估用户ID，例：8afaa9a15707483a0157262f8e78077d */ - @TableId + @TableId(value = "assess_id",type = IdType.ASSIGN_UUID) private String assessId; - - private String assessName; - /** * 所属部门名称，例：南京市供电公司 */ diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessWindLoadParam.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessWindLoadParam.java index 58851c7b3..05fc84412 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessWindLoadParam.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/po/assess/AssessWindLoadParam.java @@ -1,6 +1,5 @@ package com.njcn.advance.pojo.po.assess; -import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.njcn.db.bo.BaseEntity; import java.io.Serializable; @@ -22,8 +21,7 @@ import lombok.Setter; public class AssessWindLoadParam extends BaseEntity implements Serializable { private static final long serialVersionUID = 1L; - - @TableId + @TableId(value = "windgenerator_id",type = IdType.ASSIGN_UUID) private String windgeneratorId; private String assessId; diff --git a/pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelUtil.java b/pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelUtil.java index fe8207345..0e8350afb 100644 --- a/pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelUtil.java +++ b/pqs-advance/advance-api/src/main/java/com/njcn/advance/utils/EasyExcelUtil.java @@ -15,6 +15,7 @@ import java.net.URLEncoder; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Collectors; /** * Description: @@ -378,7 +379,50 @@ public class EasyExcelUtil { } public static void main(String[] args) { - List> maps = EasyExcelUtil.syncRead("C:\\Users\\无名\\Desktop\\11.xlsx"); + List> maps = EasyExcelUtil.syncRead("C:\\Users\\无名\\Desktop\\excel\\工作表.xlsx"); + System.out.println(maps); + List> maps1 = maps.subList(2, 51); + List> maps2 = maps.subList(51, 52); + List> maps3 = maps.subList(55, 104); + List> maps4 = maps.subList(104, 105); + List 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()); + Double 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(); + + List 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()); + + Double unbalance = 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(); } } diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/assess/SecondaryEvaluationController.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/controller/assess/SecondaryEvaluationController.java new file mode 100644 index 000000000..e0a71c7e7 --- /dev/null +++ b/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 evaluation(@RequestParam String assessId,@RequestParam("file") MultipartFile file) { + String methodDescribe = getMethodDescribe("evaluation"); + secondaryEvaluationService.evaluation(assessId,file); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS,true , methodDescribe); + } +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/SecondaryEvaluationService.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/SecondaryEvaluationService.java new file mode 100644 index 000000000..5c35c7d98 --- /dev/null +++ b/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); +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/impl/SecondaryEvaluationServiceImpl.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/assess/impl/SecondaryEvaluationServiceImpl.java new file mode 100644 index 000000000..c3aca4c7a --- /dev/null +++ b/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 iMax ; + Double unbalance; + List uMax; + Double iNeg; + try { + List> maps = EasyExcelUtil.syncRead(file.getInputStream(), 0, 0); + //电流含有率 + List> maps1 = maps.subList(3, 52); + //负序电流 + List> maps2 = maps.subList(52, 53); + //电压含有率 + List> maps3 = maps.subList(56, 105); + //三项不平衡度 + List> 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 dictDataList = dicDataFeignClient.getDicDataByTypeName (DicDataTypeEnum.DEV_VOLTAGE_STAND.getName ( )).getData ( ); + /*************************************谐波评估算法**********************************/ + + // 1. 计算单个负荷谐波阻抗和谐波电流 + //2. 计算配变谐波阻抗 并叠加 + + List loadList = new ArrayList<>(); + + List 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 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 assessWindLoadParams = iAssessWindLoadParamService.lambdaQuery().eq(AssessWindLoadParam::getAssessId, assessId).list(); + List 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 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()); + } + +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/PowerQualityAlgorithmUtil.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/PowerQualityAlgorithmUtil.java new file mode 100644 index 000000000..260dc8e34 --- /dev/null +++ b/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>> + * @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 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; + } + +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ReflectUtils.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ReflectUtils.java new file mode 100644 index 000000000..a314ee19a --- /dev/null +++ b/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; + } + + + + +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ThreePhaseUnbalanceUtil.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/ThreePhaseUnbalanceUtil.java new file mode 100644 index 000000000..3c2488f07 --- /dev/null +++ b/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% + } +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageDeviationUtil.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageDeviationUtil.java new file mode 100644 index 000000000..d30fbbb9f --- /dev/null +++ b/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; } + } +} + diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFlickerUtil.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFlickerUtil.java new file mode 100644 index 000000000..0d5a358f1 --- /dev/null +++ b/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 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;//风机闪变系数 + } +} diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFluctuationUtil.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/utils/assess/VoltageFluctuationUtil.java new file mode 100644 index 000000000..1b111d2b0 --- /dev/null +++ b/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 + } + } + } +}