diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/analysis/CanonicalCorrelationAnalysis.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/analysis/CanonicalCorrelationAnalysis.java new file mode 100644 index 000000000..f0e1085a9 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/analysis/CanonicalCorrelationAnalysis.java @@ -0,0 +1,179 @@ +package com.njcn.advance.responsibility.analysis; + +import com.njcn.advance.responsibility.constant.HarmonicConstants; +import com.njcn.advance.responsibility.utils.MathUtils; +import org.apache.commons.math3.linear.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * 典则相关分析类 + * 实现典则相关系数的计算 + * + * @author hongawen + * @version 1.0 + */ +public class CanonicalCorrelationAnalysis { + + private static final Logger logger = LoggerFactory.getLogger(CanonicalCorrelationAnalysis.class); + + /** + * 计算典则相关系数 + * 对应C代码中的TransCancor函数 + * + * @param powerData 功率数据矩阵 [时间][节点] + * @param harmonicData 谐波数据向量 + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @return 典则相关系数 + */ + public static float computeCanonicalCorrelation(float[][] powerData, float[] harmonicData, + int windowSize, int nodeCount) { + try { + // 提取窗口数据 + double[][] x = new double[windowSize][nodeCount]; + double[] y = new double[windowSize]; + + for (int i = 0; i < windowSize; i++) { + for (int j = 0; j < nodeCount; j++) { + x[i][j] = powerData[i][j]; + } + y[i] = harmonicData[i]; + } + + // 计算协方差矩阵 SXX + double[][] sxxMatrix = MathUtils.covarianceMatrix(x, windowSize, nodeCount); + + // 计算协方差 SYY + double syyMatrix = MathUtils.covariance(y, y, windowSize); + if (Math.abs(syyMatrix) < HarmonicConstants.MIN_COVARIANCE) { + syyMatrix = HarmonicConstants.MIN_COVARIANCE; + } + + // 计算协方差向量 SXY + double[] sxyVector = MathUtils.covarianceVector(x, y, windowSize, nodeCount); + + // 使用Apache Commons Math进行矩阵运算 + RealMatrix sxx = new Array2DRowRealMatrix(sxxMatrix); + RealVector sxy = new ArrayRealVector(sxyVector); + + // 计算 SXX^(-1) + DecompositionSolver solver = new LUDecomposition(sxx).getSolver(); + RealMatrix invSxx; + + if (!solver.isNonSingular()) { + // 如果矩阵奇异，使用伪逆 + logger.warn("SXX matrix is singular, using pseudo-inverse"); + SingularValueDecomposition svd = new SingularValueDecomposition(sxx); + invSxx = svd.getSolver().getInverse(); + } else { + invSxx = solver.getInverse(); + } + + // 计算 U = SXX^(-1) * SXY * (1/SYY) * SXY' + RealVector temp = invSxx.operate(sxy); + double scale = 1.0 / syyMatrix; + RealMatrix uMatrix = temp.outerProduct(sxy).scalarMultiply(scale); + + // 计算特征值 + EigenDecomposition eigenDecomposition = new EigenDecomposition(uMatrix); + double[] eigenvalues = eigenDecomposition.getRealEigenvalues(); + + // 找最大特征值 + double maxEigenvalue = 0.0; + for (double eigenvalue : eigenvalues) { + maxEigenvalue = Math.max(maxEigenvalue, Math.abs(eigenvalue)); + } + + // 典则相关系数是最大特征值的平方根 + double canonicalCorr = Math.sqrt(maxEigenvalue); + + // 限制在[0,1]范围内 + if (canonicalCorr > 1.0) { + canonicalCorr = 1.0; + } + + return (float) canonicalCorr; + + } catch (Exception e) { + logger.error("Error computing canonical correlation", e); + return 0.0f; + } + } + + /** + * 滑动窗口计算典则相关系数序列 + * 对应C代码中的SlideCanCor函数 + * + * @param powerData 功率数据矩阵 [时间][节点] + * @param harmonicData 谐波数据向量 + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @param dataLength 数据总长度 + * @return 典则相关系数序列 + */ + public static float[] slidingCanonicalCorrelation(float[][] powerData, float[] harmonicData, + int windowSize, int nodeCount, int dataLength) { + int slideLength = dataLength - windowSize; + if (slideLength <= 0) { + throw new IllegalArgumentException("Data length must be greater than window size"); + } + + float[] slideCanCor = new float[slideLength]; + + logger.info("Starting sliding canonical correlation analysis, slide length: {}", slideLength); + + for (int i = 0; i < slideLength; i++) { + // 提取窗口数据 + float[][] windowPower = new float[windowSize][nodeCount]; + float[] windowHarmonic = new float[windowSize]; + + for (int j = 0; j < windowSize; j++) { + System.arraycopy(powerData[i + j], 0, windowPower[j], 0, nodeCount); + windowHarmonic[j] = harmonicData[i + j]; + } + + // 计算当前窗口的典则相关系数 + slideCanCor[i] = computeCanonicalCorrelation(windowPower, windowHarmonic, + windowSize, nodeCount); + + if (i % 10 == 0) { + logger.debug("Processed window {}/{}", i, slideLength); + } + } + + logger.info("Sliding canonical correlation analysis completed"); + + return slideCanCor; + } + + /** + * 计算包含/不包含背景的动态相关系数 + * 对应C代码中的SlideCor函数 + * + * @param powerData 功率数据（单个节点） + * @param harmonicData 谐波数据 + * @param slideCanCor 滑动典则相关系数 + * @param windowSize 窗口大小 + * @return 动态相关系数序列 + */ + public static float[] slidingCorrelation(float[] powerData, float[] harmonicData, + float[] slideCanCor, int windowSize) { + int slideLength = slideCanCor.length; + float[] slideCor = new float[slideLength]; + + for (int i = 0; i < slideLength; i++) { + float[] tempPower = new float[windowSize]; + float[] tempHarmonic = new float[windowSize]; + + for (int j = 0; j < windowSize; j++) { + tempPower[j] = powerData[i + j]; + tempHarmonic[j] = harmonicData[i + j] * slideCanCor[i]; + } + + slideCor[i] = MathUtils.pearsonCorrelation(tempHarmonic, tempPower, windowSize); + } + + return slideCor; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/HarmonicCalculationEngine.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/HarmonicCalculationEngine.java new file mode 100644 index 000000000..a4c2f76ec --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/HarmonicCalculationEngine.java @@ -0,0 +1,424 @@ +package com.njcn.advance.responsibility.calculator; + +import com.njcn.advance.responsibility.analysis.CanonicalCorrelationAnalysis; +import com.njcn.advance.responsibility.constant.CalculationMode; +import com.njcn.advance.responsibility.constant.CalculationStatus; +import com.njcn.advance.responsibility.constant.HarmonicConstants; +import com.njcn.advance.responsibility.model.HarmonicData; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * 谐波责任计算主引擎 + * 严格对应C代码中的harm_res系列函数 + * + * @author hongawen + * @version 2.0 - 修复版本，严格对照C代码实现 + */ +public class HarmonicCalculationEngine { + + private static final Logger logger = LoggerFactory.getLogger(HarmonicCalculationEngine.class); + + // 对应C代码中的全局变量 + private int P; // 节点数 p_node + private int TL; // 功率数据长度 p_num + private int LL; // 谐波数据长度 harm_num + private int JIANGE; // 数据间隔比例 + private int width; // 窗口大小 + private float XIANE; // 谐波门槛 + + /** + * 主计算入口 + * 对应C代码中的harm_res函数 + * + * @param data 谐波数据对象 + * @return 计算是否成功 + */ + public boolean calculate(HarmonicData data) { + logger.info("Starting harmonic calculation, mode: {}", data.getCalculationMode()); + + try { + if (data.getCalculationMode() == CalculationMode.FULL_CALCULATION) { + return fullCalculation(data); + } else { + return partialCalculation(data); + } + } catch (Exception e) { + logger.error("Calculation failed with exception: " + e.getMessage(), e); + e.printStackTrace(); + data.setCalculationStatus(CalculationStatus.FAILED); + return false; + } + } + + /** + * 完整计算模式 + * 严格对应C代码中的harm_res_all函数 + * + * @param data 谐波数据对象 + * @return 计算是否成功 + */ + private boolean fullCalculation(HarmonicData data) { + logger.info("Executing full calculation mode"); + + // 1. 数据初始化 - 对应 data_init_all() + if (!initializeFullCalculationData(data)) { + logger.error("Data initialization failed"); + data.setCalculationStatus(CalculationStatus.FAILED); + return false; + } + + // 2. 创建工作数组 - 对应C代码行536-540 + float[][] a = new float[TL][P]; // 功率数据副本 + float[] b = new float[LL]; // 谐波数据副本 + float[] u = new float[TL]; // 对齐后的谐波数据 + + // 3. 复制数据 - 对应C代码行542-552 + for (int i = 0; i < TL; i++) { + for (int j = 0; j < P; j++) { + a[i][j] = data.getPowerData()[i][j]; + } + } + for (int i = 0; i < LL; i++) { + b[i] = data.getHarmonicData()[i]; + } + + // 4. 数据对齐处理 - 严格对应C代码行554-562 + // 注意：C代码是原地修改数组b + for (int i = 0; i < LL; i += JIANGE) { + float tempt = 0.0f; + for (int j = 0; j < JIANGE; j++) { + tempt += b[i + j]; + } + b[i] = tempt / JIANGE; // 覆盖原位置 + } + + // 5. 构建Udata - 严格对应C代码行570-580 + // 注意：使用 i*JIANGE 索引 + for (int i = 0; i < TL; i++) { + u[i] = b[i * JIANGE]; // 关键：使用 i*JIANGE 索引 + } + + int slcorlength = TL - width; + + // 6. 计算滑动典则相关系数 - 对应C代码行584 + logger.info("Computing sliding canonical correlation"); + float[] cancorrelation = CanonicalCorrelationAnalysis.slidingCanonicalCorrelation( + a, u, width, P, TL + ); + + // 7. 保存典则相关系数 - 对应C代码行592-601 + float[] Core = new float[slcorlength]; + float[] BjCore = new float[slcorlength]; + for (int i = 0; i < slcorlength; i++) { + Core[i] = cancorrelation[i]; + BjCore[i] = 1 - cancorrelation[i]; + } + data.setCanonicalCorrelation(Core); + data.setBackgroundCanonicalCorr(BjCore); + + // 8. 计算动态相关系数矩阵 - 对应C代码行605-635 + logger.info("Computing correlation matrix"); + float[][] simCor = new float[slcorlength][P]; + + // 对应C代码行618-632：对每个节点计算动态相关系数 + for (int i = 0; i < P; i++) { + // 提取第i个节点的功率数据 + float[] xe = new float[TL]; + for (int m = 0; m < TL; m++) { + xe[m] = a[m][i]; // 对应 Pdata.block(0, i, TL, 1) + } + + // 计算该节点的滑动相关系数 + float[] slidecor = CanonicalCorrelationAnalysis.slidingCorrelation( + xe, u, cancorrelation, width + ); + + // 存储结果 + for (int j = 0; j < slcorlength; j++) { + simCor[j][i] = slidecor[j]; + } + } + data.setCorrelationData(simCor); + + // 9. 计算EK值 - 对应C代码行642-654 + logger.info("Computing EK values"); + float[][] EKdata = ResponsibilityCalculator.computeEK( + simCor, a, width, P, TL + ); + + // 10. 计算FK值 - 对应C代码行660-673 + logger.info("Computing FK values"); + float[][] FKdata = ResponsibilityCalculator.computeFK( + EKdata, width, P, TL + ); + data.setFkData(FKdata); + + // 11. 计算HK值 - 对应C代码行678-691 + logger.info("Computing HK values"); + float[][] HKdata = ResponsibilityCalculator.computeHK( + BjCore, EKdata, width, P, TL + ); + data.setHkData(HKdata); + + // 12. 设置结果数量 - 对应C代码行693 + data.setResponsibilityDataCount(slcorlength); + + // 13. 统计超限时段的责任 - 对应C代码行696-724 + logger.info("Computing responsibility sums"); + + // 重要修正：C代码的SumHK函数中，虽然Udata长度是TL，但是循环只遍历前slg(=TL-width)个元素 + // 所以我们需要传入完整的u数组（长度TL），让sumResponsibility内部处理 + // 对应C代码：VectorXd Udata(TL); 以及 SumHK函数调用 + + // 统计HK责任（包含背景）- 对应C代码行698-710 + // 注意：传入完整的u数组（TL长度），而不是截取的数组 + float[] sumHK = ResponsibilityCalculator.sumResponsibility( + HKdata, u, XIANE, width, P + 1, TL + ); + data.setSumHKData(sumHK); + + // 统计FK责任（不包含背景）- 对应C代码行712-724 + // 同样传入完整的u数组和TL参数 + float[] sumFK = ResponsibilityCalculator.sumResponsibility( + FKdata, u, XIANE, width, P, TL + ); + data.setSumFKData(sumFK); + + // 14. 标记计算成功 - 对应C代码行739 + data.setCalculationStatus(CalculationStatus.CALCULATED); + logger.info("Full calculation completed successfully"); + + return true; + } + + /** + * 初始化完整计算数据 + * 对应C代码中的data_init_all函数 + */ + private boolean initializeFullCalculationData(HarmonicData data) { + // 设置全局变量 - 对应C代码行478-483 + P = data.getPowerNodeCount(); + TL = data.getPowerCount(); + LL = data.getHarmonicCount(); + // 对应C代码第481行：JIANGE = pq_buf.harm_num/pq_buf.p_num; + // 重要修正：JIANGE应该是 谐波数量/功率点数，不是谐波数量/节点数 + JIANGE = LL / TL; // 这个是正确的：harm_num / p_num (其中p_num是功率点数) + width = data.getWindowSize(); + XIANE = data.getHarmonicThreshold(); + + // 验证数据 - 对应C代码行485-504 + if (JIANGE * TL != LL || JIANGE < 1) { + logger.error("Data length mismatch: JIANGE({}) * TL({}) != LL({})", + JIANGE, TL, LL); + return false; + } + + if (width < HarmonicConstants.MIN_WIN_LEN || width > HarmonicConstants.MAX_WIN_LEN) { + logger.error("Invalid window size: {}", width); + return false; + } + + if (TL < 2 * width) { + logger.error("Power data length {} is too short for window size {}", TL, width); + return false; + } + + if (P > HarmonicConstants.MAX_P_NODE || TL > HarmonicConstants.MAX_P_NUM || + LL > HarmonicConstants.MAX_HARM_NUM) { + logger.error("Data size exceeds limits"); + return false; + } + + return true; + } + + /** + * 部分重算模式 + * 对应C代码中的harm_res_part函数 + * + * @param data 谐波数据对象 + * @return 计算是否成功 + */ + private boolean partialCalculation(HarmonicData data) { + logger.info("Executing partial calculation mode"); + + // 1. 数据初始化 - 对应 data_init_part() + if (!initializePartialCalculationData(data)) { + logger.error("Data initialization failed for partial calculation"); + data.setCalculationStatus(CalculationStatus.FAILED); + return false; + } + + // 2. 准备Udata - 对应C代码行816-818 + // C代码：VectorXd Udata(TL); 并从pq_buf.harm_data复制TL个元素 + int res_num = data.getResponsibilityDataCount(); + + // 验证责任数据行数 + if (res_num != TL - width) { + logger.warn("责任数据行数({})与期望值(TL-width={})不匹配", res_num, TL - width); + res_num = TL - width; // 使用正确的值 + } + + // 重要修正：与C代码保持一致，Udata长度应该是TL，而不是res_num + // C代码：VectorXd Udata(TL); + float[] Udata = new float[TL]; + + // 从harm_data复制TL个元素到Udata + // C代码：for (int j = 0; j < TL; j++) Udata[j] = pq_buf.harm_data[j]; + if (data.getHarmonicData().length < TL) { + logger.warn("谐波数据长度({})小于TL({}), 将补零", + data.getHarmonicData().length, TL); + System.arraycopy(data.getHarmonicData(), 0, Udata, 0, data.getHarmonicData().length); + // 剩余部分自动补零 + } else { + System.arraycopy(data.getHarmonicData(), 0, Udata, 0, TL); + } + + logger.debug("准备Udata完成: 长度={} (对应C代码TL), 责任数据行数={}", Udata.length, res_num); + + // 3. 统计HK责任 - 对应C代码行806-830 + logger.info("Recalculating HK responsibility sums"); + + // 对应C代码第808-814行：创建新的HKdata矩阵，只包含RES_NUM行 + // C代码：MatrixXd HKdata(RES_NUM, (P + 1)); + + // 添加数据验证 + if (data.getHkData() == null || data.getHkData().length == 0) { + logger.error("HK数据为空或长度为0"); + data.setCalculationStatus(CalculationStatus.FAILED); + return false; + } + + // 重要：C代码创建了新的RES_NUM行的HKdata，从原始数据复制前RES_NUM行 + // 对应C代码第808-814行 + float[][] HKdataForCalc = new float[res_num][P + 1]; + int copyRows = Math.min(res_num, data.getHkData().length); + + logger.debug("创建用于计算的HK数据矩阵: {}x{}, 从原始数据复制{}行", + res_num, P + 1, copyRows); + + for (int i = 0; i < copyRows; i++) { + for (int j = 0; j < P + 1; j++) { + if (j < data.getHkData()[i].length) { + HKdataForCalc[i][j] = data.getHkData()[i][j]; + } + } + } + + + logger.debug("调用HK sumResponsibility参数: HKdata[{}x{}], Udata[{}], TL={}, width={}", + HKdataForCalc.length, HKdataForCalc.length > 0 ? HKdataForCalc[0].length : 0, + Udata.length, TL, width); + + try { + // 对应C代码第819行：arrHKsum = SumHK(HKdata, Udata, wdith, colK, TL); + float[] sumHK = ResponsibilityCalculator.sumResponsibility( + HKdataForCalc, // 使用新创建的RES_NUM行的HK数据 + Udata, // 长度为TL的数组 + XIANE, + width, + P + 1, + TL // 传入TL参数 + ); + data.setSumHKData(sumHK); + logger.debug("HK责任计算完成，结果长度: {}", sumHK != null ? sumHK.length : "null"); + } catch (Exception e) { + logger.error("HK责任计算失败: " + e.getMessage(), e); + throw e; + } + + // 4. 统计FK责任 - 对应C代码行839-851 + logger.info("Recalculating FK responsibility sums"); + + // 对应C代码：虽然没有显式创建新的FKdata，但逻辑相同 + + // 添加数据验证 + if (data.getFkData() == null || data.getFkData().length == 0) { + logger.error("FK数据为空或长度为0"); + data.setCalculationStatus(CalculationStatus.FAILED); + return false; + } + + // 创建用于计算的FK数据矩阵（RES_NUM行） + float[][] FKdataForCalc = new float[res_num][P]; + int copyRowsFK = Math.min(res_num, data.getFkData().length); + + logger.debug("创建用于计算的FK数据矩阵: {}x{}, 从原始数据复制{}行", + res_num, P, copyRowsFK); + + for (int i = 0; i < copyRowsFK; i++) { + for (int j = 0; j < P; j++) { + if (j < data.getFkData()[i].length) { + FKdataForCalc[i][j] = data.getFkData()[i][j]; + } + } + } + + + logger.debug("调用FK sumResponsibility参数: FKdata[{}x{}], Udata[{}], TL={}, width={}", + FKdataForCalc.length, FKdataForCalc.length > 0 ? FKdataForCalc[0].length : 0, + Udata.length, TL, width); + + try { + // 对应C代码第840行：arrHKsum = SumHK(FKdata, Udata, wdith, colK, TL); + float[] sumFK = ResponsibilityCalculator.sumResponsibility( + FKdataForCalc, // 使用新创建的RES_NUM行的FK数据 + Udata, // 使用相同的Udata(长度TL) + XIANE, + width, + P, + TL // 传入TL参数 + ); + data.setSumFKData(sumFK); + logger.debug("FK责任计算完成，结果长度: {}", sumFK != null ? sumFK.length : "null"); + } catch (Exception e) { + logger.error("FK责任计算失败: " + e.getMessage(), e); + throw e; + } + + // 5. 标记计算成功 - 对应C代码行858 + data.setCalculationStatus(CalculationStatus.CALCULATED); + logger.info("Partial calculation completed successfully"); + + return true; + } + + /** + * 初始化部分计算数据 + * 对应C代码中的data_init_part函数 + */ + private boolean initializePartialCalculationData(HarmonicData data) { + // 设置变量 - 对应C代码行762-766 + int RES_NUM = data.getResponsibilityDataCount(); + P = data.getPowerNodeCount(); + TL = data.getWindowSize() + RES_NUM; + width = data.getWindowSize(); + XIANE = data.getHarmonicThreshold(); + + // 验证数据 - 对应C代码行756-778 + if ((RES_NUM + width) != data.getHarmonicCount()) { + logger.error("Data length mismatch: res_num({}) + win({}) != harm_num({})", + RES_NUM, width, data.getHarmonicCount()); + return false; + } + + if (width < HarmonicConstants.MIN_WIN_LEN || width > HarmonicConstants.MAX_WIN_LEN) { + logger.error("Invalid window size: {}", width); + return false; + } + + if (P > HarmonicConstants.MAX_P_NODE || TL > HarmonicConstants.MAX_P_NUM) { + logger.error("Data size exceeds limits"); + return false; + } + + // 验证FK和HK数据存在 + if (data.getFkData() == null || data.getHkData() == null) { + logger.error("FK or HK data is null"); + return false; + } + + return true; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/ResponsibilityCalculator.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/ResponsibilityCalculator.java new file mode 100644 index 000000000..26e131786 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/calculator/ResponsibilityCalculator.java @@ -0,0 +1,346 @@ +package com.njcn.advance.responsibility.calculator; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * 责任指标计算类 + * 计算谐波责任的各项指标 + * 严格对应C代码实现 + * + * @author hongawen + * @version 2.0 - 修复版本，严格对照C代码实现 + */ +public class ResponsibilityCalculator { + + private static final Logger logger = LoggerFactory.getLogger(ResponsibilityCalculator.class); + + /** + * 计算EK值（动态责任指标） + * 严格对应C代码中的DyEKCom函数（行300-357） + * + * @param correlationData 动态相关系数矩阵 [时间][节点] + * @param powerData 功率数据矩阵 [时间][节点] + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @param dataLength 数据长度 + * @return EK值矩阵 + */ + public static float[][] computeEK(float[][] correlationData, float[][] powerData, + int windowSize, int nodeCount, int dataLength) { + int slideLength = dataLength - windowSize; + float[][] ekData = new float[slideLength][nodeCount]; + float[][] akData = new float[slideLength][nodeCount]; + + logger.info("Computing EK values, slide length: {}", slideLength); + + // 计算AK值 - 对应C代码行307-319 + for (int i = 0; i < slideLength; i++) { + float sumPower = 0; + + // 计算功率总和 - 对应C代码行309-313 + for (int j = 0; j < nodeCount; j++) { + sumPower += powerData[i][j]; // 注意：这里用的是powerData[i][j] + } + + // 计算AK值 - 对应C代码行314-318 + for (int j = 0; j < nodeCount; j++) { + if (sumPower > 0) { + akData[i][j] = correlationData[i][j] * (powerData[i][j] / sumPower); + } else { + akData[i][j] = 0; + } + } + } + + // 归一化处理得到EK值 - 对应C代码行320-342 + for (int i = 0; i < slideLength; i++) { + // 重要：C代码初始化为0，而不是Float.MIN_VALUE/MAX_VALUE + // 对应C代码行322-323 + float maxValue = 0; + float minValue = 0; + + // 找最大最小值 - 对应C代码行322-334 + for (int j = 0; j < nodeCount; j++) { + if (akData[i][j] > maxValue) { + maxValue = akData[i][j]; + } + if (akData[i][j] < minValue) { + minValue = akData[i][j]; + } + } + + float range = maxValue - minValue; + + // 归一化 - 对应C代码行338-341 + for (int j = 0; j < nodeCount; j++) { + if (Math.abs(range) > 1e-10) { + ekData[i][j] = (akData[i][j] - minValue) / range; + } else { + ekData[i][j] = 0; + } + } + } + + logger.info("EK computation completed"); + + return ekData; + } + + /** + * 计算FK值（不包含背景的责任指标） + * 严格对应C代码中的DyFKCom函数（行358-389） + * + * @param ekData EK值矩阵 + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @param dataLength 数据长度 + * @return FK值矩阵 + */ + public static float[][] computeFK(float[][] ekData, int windowSize, + int nodeCount, int dataLength) { + int slideLength = dataLength - windowSize; + float[][] fkData = new float[slideLength][nodeCount]; + + logger.info("Computing FK values"); + + // 对应C代码行364-376 + for (int i = 0; i < slideLength; i++) { + float sumEK = 0; + + // 计算EK总和 - 对应C代码行366-370 + for (int j = 0; j < nodeCount; j++) { + sumEK += ekData[i][j]; + } + + // 计算FK值（归一化）- 对应C代码行372-375 + for (int j = 0; j < nodeCount; j++) { + if (sumEK > 0) { + fkData[i][j] = ekData[i][j] / sumEK; + } else { + fkData[i][j] = 0; + } + } + } + + logger.info("FK computation completed"); + + return fkData; + } + + /** + * 计算HK值（包含背景的责任指标） + * 严格对应C代码中的DyHKCom函数（行390-429） + * + * @param backgroundCanCor 背景典则相关系数（1-典则相关系数） + * @param ekData EK值矩阵 + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @param dataLength 数据长度 + * @return HK值矩阵 + */ + public static float[][] computeHK(float[] backgroundCanCor, float[][] ekData, + int windowSize, int nodeCount, int dataLength) { + int slideLength = dataLength - windowSize; + float[][] hkData = new float[slideLength][nodeCount + 1]; + float[][] newEK = new float[slideLength][nodeCount + 1]; + + logger.info("Computing HK values"); + + // 构建包含背景的EK矩阵 - 对应C代码行396-403 + for (int i = 0; i < slideLength; i++) { + // 复制原有EK值 + for (int j = 0; j < nodeCount; j++) { + newEK[i][j] = ekData[i][j]; + } + // 添加背景值 + newEK[i][nodeCount] = backgroundCanCor[i]; + } + + // 计算HK值 - 对应C代码行405-416 + for (int i = 0; i < slideLength; i++) { + float sumEK = 0; + + // 计算总和 - 对应C代码行407-411 + for (int j = 0; j < nodeCount + 1; j++) { + sumEK += newEK[i][j]; + } + + // 归一化得到HK值 - 对应C代码行412-415 + for (int j = 0; j < nodeCount + 1; j++) { + if (sumEK > 0) { + hkData[i][j] = newEK[i][j] / sumEK; + } else { + hkData[i][j] = 0; + } + } + } + + logger.info("HK computation completed"); + + return hkData; + } + + /** + * 计算超限时段的责任总和 + * 严格对应C代码中的SumHK函数（行431-461） + * + * @param responsibilityData 责任数据矩阵（FK或HK）[时间][节点] + * @param harmonicData 谐波数据（Udata） - 长度为TL + * @param threshold 谐波门槛（XIANE） + * @param windowSize 窗口大小 + * @param columnCount 列数（节点数或节点数+1） + * @param tl_num 对应C代码的TL参数（总数据点数） + * @return 各节点的责任总和百分比 + */ + public static float[] sumResponsibility(float[][] responsibilityData, float[] harmonicData, + float threshold, int windowSize, int columnCount, int tl_num) { + // 对应C代码：int slg = tl_num - width; + int slideLength = tl_num - windowSize; // 使用传入的tl_num计算，而不是从responsibilityData.length推断 + float[] sumData = new float[columnCount]; // 对应C代码中的 arrHKsum + double[] HKSum = new double[columnCount]; // 对应C代码中的 VectorXd HKSum - 使用double精度 + int exceedCount = 0; // 对应C代码中的 coutt + + logger.debug("sumResponsibility参数: threshold={}, windowSize={}, columnCount={}, tl_num={}, slideLength={}", + threshold, windowSize, columnCount, tl_num, slideLength); + + // 数据验证 + if (harmonicData == null) { + logger.error("错误: harmonicData为null!"); + throw new NullPointerException("harmonicData不能为null"); + } + + if (responsibilityData == null) { + logger.error("错误: responsibilityData为null!"); + throw new NullPointerException("responsibilityData不能为null"); + } + + + // 关键验证：检查数组长度是否充足 + // C代码中Udata长度是TL，循环遍历slg=TL-width个元素 + logger.debug("数据验证: slideLength={}, harmonicData.length={}, responsibilityData.length={}", + slideLength, harmonicData.length, responsibilityData.length); + + if (harmonicData.length < slideLength) { + logger.error("!!!谐波数据长度不足!!!"); + logger.error("需要访问harmonicData[0]到harmonicData[{}], 但数组长度只有{}", + slideLength - 1, harmonicData.length); + throw new IllegalArgumentException( + String.format("谐波数据长度不足: 需要%d, 实际%d", slideLength, harmonicData.length)); + } + + if (responsibilityData.length < slideLength) { + logger.error("!!!责任数据行数不足!!!"); + logger.error("需要访问responsibilityData[0]到responsibilityData[{}], 但数组长度只有{}", + slideLength - 1, responsibilityData.length); + throw new IllegalArgumentException( + String.format("责任数据行数不足: 需要%d, 实际%d", slideLength, responsibilityData.length)); + } + + // 统计超限时段的责任 - 对应C代码行437-449 + // 重要：C代码中有一个设计缺陷：coutt在每个j循环中被重置， + // 但最后计算百分比时使用的是最后一次j循环的coutt值 + // 为了严格保持一致，我们也要复现这个逻辑 + for (int j = 0; j < columnCount; j++) { + HKSum[j] = 0; + exceedCount = 0; // 对应C代码行440: coutt = 0; + + for (int i = 0; i < slideLength; i++) { + // 添加越界检查 + if (i >= harmonicData.length) { + logger.error("!!!数组越界!!! 尝试访问harmonicData[{}], 但数组长度只有{}", + i, harmonicData.length); + logger.error("发生在: j={}, i={}", j, i); + throw new ArrayIndexOutOfBoundsException( + String.format("访问harmonicData[%d]越界, 数组长度=%d", i, harmonicData.length)); + } + + // 对应C代码行443-447 + if (harmonicData[i] > threshold) { + HKSum[j] += responsibilityData[i][j]; // 对应C代码行445 + exceedCount++; // 对应C代码行446 + } + } + } + // 注意：这里exceedCount保留的是最后一列（j=columnCount-1）的超限次数 + // 这与C代码的行为一致 + + logger.debug("最终exceedCount={} (来自最后一列的计算)", exceedCount); + + // 计算平均责任百分比 - 对应C代码行453-459 + for (int i = 0; i < columnCount; i++) { + sumData[i] = 0; // 对应C代码行454 + } + + for (int i = 0; i < columnCount; i++) { + if (exceedCount > 0) { + // 对应C代码行458: arrHKsum[i] = 100 * (HKSum(i)/coutt); + // 使用double进行计算，然后转换为float + sumData[i] = (float)(100.0 * (HKSum[i] / (double)exceedCount)); + } + } + + logger.info("Exceeded count: {}, average responsibilities calculated", exceedCount); + + return sumData; + } + + /** + * 计算超限时段的责任总和（兼容版本） + * 为了向后兼容，保留不带tl_num参数的版本 + * + * @param responsibilityData 责任数据矩阵（FK或HK）[时间][节点] + * @param harmonicData 谐波数据（Udata） + * @param threshold 谐波门槛（XIANE） + * @param windowSize 窗口大小 + * @param columnCount 列数（节点数或节点数+1） + * @return 各节点的责任总和百分比 + */ + public static float[] sumResponsibility(float[][] responsibilityData, float[] harmonicData, + float threshold, int windowSize, int columnCount) { + // 如果没有提供tl_num，从数据推断 + int tl_num = responsibilityData.length + windowSize; + return sumResponsibility(responsibilityData, harmonicData, threshold, windowSize, columnCount, tl_num); + } + + /** + * 计算所有节点的动态相关系数矩阵 + * 这个函数在主引擎中已经内联实现，这里保留作为辅助方法 + * + * @param powerData 功率数据矩阵 + * @param harmonicData 谐波数据 + * @param canonicalCorr 典则相关系数序列 + * @param windowSize 窗口大小 + * @param nodeCount 节点数量 + * @return 动态相关系数矩阵 + */ + public static float[][] computeCorrelationMatrix(float[][] powerData, float[] harmonicData, + float[] canonicalCorr, int windowSize, + int nodeCount) { + int slideLength = canonicalCorr.length; + float[][] correlationMatrix = new float[slideLength][nodeCount]; + + logger.info("Computing correlation matrix for all nodes"); + + for (int nodeIdx = 0; nodeIdx < nodeCount; nodeIdx++) { + // 提取单个节点的功率数据 + float[] nodePower = new float[powerData.length]; + for (int i = 0; i < powerData.length; i++) { + nodePower[i] = powerData[i][nodeIdx]; + } + + // 计算该节点的动态相关系数 + float[] nodeCorr = com.njcn.advance.responsibility.analysis.CanonicalCorrelationAnalysis + .slidingCorrelation(nodePower, harmonicData, canonicalCorr, windowSize); + + // 存储结果 + for (int i = 0; i < slideLength; i++) { + correlationMatrix[i][nodeIdx] = nodeCorr[i]; + } + } + + logger.info("Correlation matrix computation completed"); + + return correlationMatrix; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationMode.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationMode.java new file mode 100644 index 000000000..703132337 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationMode.java @@ -0,0 +1,46 @@ +package com.njcn.advance.responsibility.constant; + +/** + * 计算模式枚举 + * + * @author hongawen + * @version 1.0 + */ +public enum CalculationMode { + /** + * 完整计算模式 + * 使用电压和功率数据计算相关系数和责任 + */ + FULL_CALCULATION(0, "完整计算模式"), + + /** + * 部分重算模式 + * 使用已有的动态相关系数计算责任 + */ + PARTIAL_RECALCULATION(1, "部分重算模式"); + + private final int code; + private final String description; + + CalculationMode(int code, String description) { + this.code = code; + this.description = description; + } + + public int getCode() { + return code; + } + + public String getDescription() { + return description; + } + + public static CalculationMode fromCode(int code) { + for (CalculationMode mode : values()) { + if (mode.code == code) { + return mode; + } + } + throw new IllegalArgumentException("Invalid calculation mode code: " + code); + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationStatus.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationStatus.java new file mode 100644 index 000000000..4ced21b96 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/CalculationStatus.java @@ -0,0 +1,49 @@ +package com.njcn.advance.responsibility.constant; + +/** + * 计算状态枚举 + * + * @author hongawen + * @version 1.0 + */ +public enum CalculationStatus { + /** + * 未计算 + */ + NOT_CALCULATED(0, "未计算"), + + /** + * 计算完成 + */ + CALCULATED(1, "计算完成"), + + /** + * 计算失败 + */ + FAILED(-1, "计算失败"); + + private final int code; + private final String description; + + CalculationStatus(int code, String description) { + this.code = code; + this.description = description; + } + + public int getCode() { + return code; + } + + public String getDescription() { + return description; + } + + public static CalculationStatus fromCode(int code) { + for (CalculationStatus status : values()) { + if (status.code == code) { + return status; + } + } + return NOT_CALCULATED; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/HarmonicConstants.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/HarmonicConstants.java new file mode 100644 index 000000000..8b2bc02d6 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/constant/HarmonicConstants.java @@ -0,0 +1,60 @@ +package com.njcn.advance.responsibility.constant; + +/** + * 谐波责任量化系统常量定义 + * + * @author hongawen + * @version 1.0 + */ +public final class HarmonicConstants { + + private HarmonicConstants() { + // 防止实例化 + } + + /** + * 最大谐波数据个数 (1440*100) + * 按一分钟间隔，100天处理 + */ + public static final int MAX_HARM_NUM = 144000; + + /** + * 最大功率数据个数 (96*100) + * 按15分钟间隔，100天处理 + */ + public static final int MAX_P_NUM = 9600; + + /** + * 最大功率节点个数 + * 按200个限制 + */ + public static final int MAX_P_NODE = 200; + + /** + * 最大数据窗长度 (96*10) + * 按15分钟算10天 + */ + public static final int MAX_WIN_LEN = 960; + + /** + * 最小数据窗长度 + * 按15分钟算一小时 + */ + public static final int MIN_WIN_LEN = 4; + + /** + * 默认数据窗大小 + * 一天的数据量（15分钟间隔） + */ + public static final int DEFAULT_WINDOW_SIZE = 96; + + /** + * 数值计算精度阈值 + */ + public static final double EPSILON = 1e-10; + + /** + * 协方差计算最小值（避免除零） + */ + public static final double MIN_COVARIANCE = 1e-5; +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/model/HarmonicData.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/model/HarmonicData.java new file mode 100644 index 000000000..06757df16 --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/model/HarmonicData.java @@ -0,0 +1,286 @@ +package com.njcn.advance.responsibility.model; + +import com.njcn.advance.responsibility.constant.CalculationMode; +import com.njcn.advance.responsibility.constant.CalculationStatus; +import com.njcn.advance.responsibility.constant.HarmonicConstants; + +/** + * 谐波数据结构类 + * 对应C语言中的harm_data_struct结构体 + * + * @author hongawen + * @version 1.0 + */ +public class HarmonicData { + + // 输入参数 + private CalculationMode calculationMode; // 计算标志 + private int harmonicCount; // 谐波数据个数 + private int powerCount; // 功率数据个数 + private int powerNodeCount; // 功率负荷节点数 + private int windowSize; // 数据窗大小 + private int responsibilityDataCount; // 代入的责任数据个数 + private float harmonicThreshold; // 谐波电压门槛 + + // 数据数组 + private float[] harmonicData; // 谐波数据序列 + private float[][] powerData; // 功率数据序列 + + // 输入输出数据 + private float[][] correlationData; // 动态相关系数数据序列 + private float[][] fkData; // 不包含背景动态谐波责任数据序列 + private float[][] hkData; // 包含背景动态谐波责任数据序列 + private float[] canonicalCorrelation; // 典则相关系数 + private float[] backgroundCanonicalCorr; // 包含背景典则相关系数 + + // 输出结果 + private CalculationStatus calculationStatus; // 计算状态 + private float[] sumFKData; // 不包含背景谐波责任 + private float[] sumHKData; // 包含背景谐波责任 + + /** + * 默认构造函数 + */ + public HarmonicData() { + this.calculationMode = CalculationMode.FULL_CALCULATION; + this.calculationStatus = CalculationStatus.NOT_CALCULATED; + this.windowSize = HarmonicConstants.DEFAULT_WINDOW_SIZE; + } + + /** + * Builder模式构造器 + */ + public static class Builder { + private HarmonicData data = new HarmonicData(); + + public Builder calculationMode(CalculationMode mode) { + data.calculationMode = mode; + return this; + } + + public Builder harmonicCount(int count) { + data.harmonicCount = count; + return this; + } + + public Builder powerCount(int count) { + data.powerCount = count; + return this; + } + + public Builder powerNodeCount(int count) { + data.powerNodeCount = count; + return this; + } + + public Builder windowSize(int size) { + data.windowSize = size; + return this; + } + + public Builder harmonicThreshold(float threshold) { + data.harmonicThreshold = threshold; + return this; + } + + public Builder harmonicData(float[] data) { + this.data.harmonicData = data; + return this; + } + + public Builder powerData(float[][] data) { + this.data.powerData = data; + return this; + } + + public HarmonicData build() { + // 验证数据 + validateData(); + // 初始化数组 + initializeArrays(); + return data; + } + + private void validateData() { + if (data.harmonicCount <= 0 || data.harmonicCount > HarmonicConstants.MAX_HARM_NUM) { + throw new IllegalArgumentException("Invalid harmonic count: " + data.harmonicCount); + } + if (data.powerCount <= 0 || data.powerCount > HarmonicConstants.MAX_P_NUM) { + throw new IllegalArgumentException("Invalid power count: " + data.powerCount); + } + if (data.powerNodeCount <= 0 || data.powerNodeCount > HarmonicConstants.MAX_P_NODE) { + throw new IllegalArgumentException("Invalid power node count: " + data.powerNodeCount); + } + if (data.windowSize < HarmonicConstants.MIN_WIN_LEN || + data.windowSize > HarmonicConstants.MAX_WIN_LEN) { + throw new IllegalArgumentException("Invalid window size: " + data.windowSize); + } + + // 验证数据对齐 + if (data.calculationMode == CalculationMode.FULL_CALCULATION) { + int ratio = data.harmonicCount / data.powerCount; + if (ratio * data.powerCount != data.harmonicCount || ratio < 1) { + throw new IllegalArgumentException("Harmonic data count must be integer multiple of power data count"); + } + } + } + + private void initializeArrays() { + if (data.harmonicData == null) { + data.harmonicData = new float[data.harmonicCount]; + } + if (data.powerData == null) { + data.powerData = new float[data.powerCount][data.powerNodeCount]; + } + + int resultCount = data.powerCount - data.windowSize; + if (resultCount > 0) { + data.correlationData = new float[resultCount][data.powerNodeCount]; + data.fkData = new float[resultCount][data.powerNodeCount]; + data.hkData = new float[resultCount][data.powerNodeCount + 1]; + data.canonicalCorrelation = new float[resultCount]; + data.backgroundCanonicalCorr = new float[resultCount]; + } + + data.sumFKData = new float[data.powerNodeCount]; + data.sumHKData = new float[data.powerNodeCount + 1]; + } + } + + // Getters and Setters + public CalculationMode getCalculationMode() { + return calculationMode; + } + + public void setCalculationMode(CalculationMode calculationMode) { + this.calculationMode = calculationMode; + } + + public int getHarmonicCount() { + return harmonicCount; + } + + public void setHarmonicCount(int harmonicCount) { + this.harmonicCount = harmonicCount; + } + + public int getPowerCount() { + return powerCount; + } + + public void setPowerCount(int powerCount) { + this.powerCount = powerCount; + } + + public int getPowerNodeCount() { + return powerNodeCount; + } + + public void setPowerNodeCount(int powerNodeCount) { + this.powerNodeCount = powerNodeCount; + } + + public int getWindowSize() { + return windowSize; + } + + public void setWindowSize(int windowSize) { + this.windowSize = windowSize; + } + + public int getResponsibilityDataCount() { + return responsibilityDataCount; + } + + public void setResponsibilityDataCount(int responsibilityDataCount) { + this.responsibilityDataCount = responsibilityDataCount; + } + + public float getHarmonicThreshold() { + return harmonicThreshold; + } + + public void setHarmonicThreshold(float harmonicThreshold) { + this.harmonicThreshold = harmonicThreshold; + } + + public float[] getHarmonicData() { + return harmonicData; + } + + public void setHarmonicData(float[] harmonicData) { + this.harmonicData = harmonicData; + } + + public float[][] getPowerData() { + return powerData; + } + + public void setPowerData(float[][] powerData) { + this.powerData = powerData; + } + + public float[][] getCorrelationData() { + return correlationData; + } + + public void setCorrelationData(float[][] correlationData) { + this.correlationData = correlationData; + } + + public float[][] getFkData() { + return fkData; + } + + public void setFkData(float[][] fkData) { + this.fkData = fkData; + } + + public float[][] getHkData() { + return hkData; + } + + public void setHkData(float[][] hkData) { + this.hkData = hkData; + } + + public float[] getCanonicalCorrelation() { + return canonicalCorrelation; + } + + public void setCanonicalCorrelation(float[] canonicalCorrelation) { + this.canonicalCorrelation = canonicalCorrelation; + } + + public float[] getBackgroundCanonicalCorr() { + return backgroundCanonicalCorr; + } + + public void setBackgroundCanonicalCorr(float[] backgroundCanonicalCorr) { + this.backgroundCanonicalCorr = backgroundCanonicalCorr; + } + + public CalculationStatus getCalculationStatus() { + return calculationStatus; + } + + public void setCalculationStatus(CalculationStatus calculationStatus) { + this.calculationStatus = calculationStatus; + } + + public float[] getSumFKData() { + return sumFKData; + } + + public void setSumFKData(float[] sumFKData) { + this.sumFKData = sumFKData; + } + + public float[] getSumHKData() { + return sumHKData; + } + + public void setSumHKData(float[] sumHKData) { + this.sumHKData = sumHKData; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/IHarmonicResponsibilityService.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/IHarmonicResponsibilityService.java new file mode 100644 index 000000000..4dcbd58af --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/IHarmonicResponsibilityService.java @@ -0,0 +1,61 @@ +package com.njcn.advance.responsibility.service; + +import com.njcn.advance.responsibility.model.HarmonicData; + +/** + * 谐波责任计算服务接口 + * + * @author hongawen + * @version 1.0 + */ +public interface IHarmonicResponsibilityService { + + /** + * 执行谐波责任计算 + * + * @param data 输入的谐波数据 + * @return 计算是否成功 + */ + boolean calculate(HarmonicData data); + + /** + * 执行完整计算 + * + * @param harmonicData 谐波数据数组 + * @param powerData 功率数据矩阵 + * @param harmonicCount 谐波数据个数 + * @param powerCount 功率数据个数 + * @param nodeCount 节点数量 + * @param windowSize 窗口大小 + * @param threshold 谐波门槛 + * @return 计算结果 + */ + HarmonicData fullCalculation(float[] harmonicData, float[][] powerData, + int harmonicCount, int powerCount, int nodeCount, + int windowSize, float threshold); + + /** + * 执行部分重算 + * + * @param harmonicData 谐波数据数组 + * @param fkData FK数据矩阵 + * @param hkData HK数据矩阵 + * @param harmonicCount 谐波数据个数 + * @param nodeCount 节点数量 + * @param windowSize 窗口大小 + * @param responsibilityCount 责任数据个数 + * @param threshold 谐波门槛 + * @return 计算结果 + */ + HarmonicData partialCalculation(float[] harmonicData, float[][] fkData, float[][] hkData, + int harmonicCount, int nodeCount, int windowSize, + int responsibilityCount, float threshold); + + /** + * 验证输入数据的有效性 + * + * @param data 待验证的数据 + * @return 验证结果消息，null表示验证通过 + */ + String validateData(HarmonicData data); +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/impl/HarmonicResponsibilityServiceImpl.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/impl/HarmonicResponsibilityServiceImpl.java new file mode 100644 index 000000000..c8f6bc75c --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/service/impl/HarmonicResponsibilityServiceImpl.java @@ -0,0 +1,162 @@ +package com.njcn.advance.responsibility.service.impl; + +import com.njcn.advance.responsibility.calculator.HarmonicCalculationEngine; +import com.njcn.advance.responsibility.constant.CalculationMode; +import com.njcn.advance.responsibility.constant.HarmonicConstants; +import com.njcn.advance.responsibility.model.HarmonicData; +import com.njcn.advance.responsibility.service.IHarmonicResponsibilityService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; + +/** + * 谐波责任计算服务实现类 + * + * @author hongawen + * @version 1.0 + */ +@Service +public class HarmonicResponsibilityServiceImpl implements IHarmonicResponsibilityService { + + private static final Logger logger = LoggerFactory.getLogger(HarmonicResponsibilityServiceImpl.class); + + private final HarmonicCalculationEngine engine; + + public HarmonicResponsibilityServiceImpl() { + this.engine = new HarmonicCalculationEngine(); + } + + @Override + public boolean calculate(HarmonicData data) { + if (data == null) { + logger.error("Input data is null"); + return false; + } + + String validationError = validateData(data); + if (validationError != null) { + logger.error("Data validation failed: {}", validationError); + return false; + } + + long startTime = System.currentTimeMillis(); + boolean result = engine.calculate(data); + long endTime = System.currentTimeMillis(); + + logger.info("Calculation completed in {} ms, result: {}", (endTime - startTime), result); + + return result; + } + + @Override + public HarmonicData fullCalculation(float[] harmonicData, float[][] powerData, + int harmonicCount, int powerCount, int nodeCount, + int windowSize, float threshold) { + logger.info("Starting full calculation with harmonicCount={}, powerCount={}, nodeCount={}, windowSize={}", + harmonicCount, powerCount, nodeCount, windowSize); + + HarmonicData data = new HarmonicData.Builder() + .calculationMode(CalculationMode.FULL_CALCULATION) + .harmonicCount(harmonicCount) + .powerCount(powerCount) + .powerNodeCount(nodeCount) + .windowSize(windowSize) + .harmonicThreshold(threshold) + .harmonicData(harmonicData) + .powerData(powerData) + .build(); + + calculate(data); + + return data; + } + + @Override + public HarmonicData partialCalculation(float[] harmonicData, float[][] fkData, float[][] hkData, + int harmonicCount, int nodeCount, int windowSize, + int responsibilityCount, float threshold) { + logger.info("Starting partial calculation with harmonicCount={}, nodeCount={}, windowSize={}, responsibilityCount={}", + harmonicCount, nodeCount, windowSize, responsibilityCount); + + HarmonicData data = new HarmonicData(); + data.setCalculationMode(CalculationMode.PARTIAL_RECALCULATION); + data.setHarmonicCount(harmonicCount); + data.setPowerNodeCount(nodeCount); + data.setWindowSize(windowSize); + data.setResponsibilityDataCount(responsibilityCount); + data.setHarmonicThreshold(threshold); + data.setHarmonicData(harmonicData); + data.setFkData(fkData); + data.setHkData(hkData); + + // 初始化输出数组 + data.setSumFKData(new float[nodeCount]); + data.setSumHKData(new float[nodeCount + 1]); + + calculate(data); + + return data; + } + + @Override + public String validateData(HarmonicData data) { + if (data == null) { + return "Data object is null"; + } + + // 验证基本参数 + if (data.getHarmonicCount() <= 0 || data.getHarmonicCount() > HarmonicConstants.MAX_HARM_NUM) { + return String.format("Invalid harmonic count: %d (should be 1-%d)", + data.getHarmonicCount(), HarmonicConstants.MAX_HARM_NUM); + } + + if (data.getCalculationMode() == CalculationMode.FULL_CALCULATION) { + // 完整计算模式验证 + if (data.getPowerCount() <= 0 || data.getPowerCount() > HarmonicConstants.MAX_P_NUM) { + return String.format("Invalid power count: %d (should be 1-%d)", + data.getPowerCount(), HarmonicConstants.MAX_P_NUM); + } + + if (data.getPowerNodeCount() <= 0 || data.getPowerNodeCount() > HarmonicConstants.MAX_P_NODE) { + return String.format("Invalid power node count: %d (should be 1-%d)", + data.getPowerNodeCount(), HarmonicConstants.MAX_P_NODE); + } + + // 验证数据对齐 + int ratio = data.getHarmonicCount() / data.getPowerCount(); + if (ratio * data.getPowerCount() != data.getHarmonicCount()) { + return String.format("Harmonic count %d is not aligned with power count %d", + data.getHarmonicCount(), data.getPowerCount()); + } + + // 验证数据数组 + if (data.getHarmonicData() == null || data.getHarmonicData().length < data.getHarmonicCount()) { + return "Harmonic data array is null or insufficient"; + } + + if (data.getPowerData() == null || data.getPowerData().length < data.getPowerCount()) { + return "Power data array is null or insufficient"; + } + + } else if (data.getCalculationMode() == CalculationMode.PARTIAL_RECALCULATION) { + // 部分计算模式验证 + if (data.getResponsibilityDataCount() + data.getWindowSize() != data.getHarmonicCount()) { + return String.format("Data length mismatch: resNum(%d) + winSize(%d) != harmCount(%d)", + data.getResponsibilityDataCount(), data.getWindowSize(), data.getHarmonicCount()); + } + + if (data.getFkData() == null || data.getHkData() == null) { + return "FK or HK data is null for partial calculation"; + } + } + + // 验证窗口大小 + if (data.getWindowSize() < HarmonicConstants.MIN_WIN_LEN || + data.getWindowSize() > HarmonicConstants.MAX_WIN_LEN) { + return String.format("Invalid window size: %d (should be %d-%d)", + data.getWindowSize(), HarmonicConstants.MIN_WIN_LEN, HarmonicConstants.MAX_WIN_LEN); + } + + return null; // 验证通过 + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/utils/MathUtils.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/utils/MathUtils.java new file mode 100644 index 000000000..b4ee342fe --- /dev/null +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/responsibility/utils/MathUtils.java @@ -0,0 +1,314 @@ +package com.njcn.advance.responsibility.utils; + +import com.njcn.advance.responsibility.constant.HarmonicConstants; +import org.apache.commons.math3.linear.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * 数学工具类 + * 提供基础数学计算功能 + * + * @author hongawen + * @version 1.0 + */ +public class MathUtils { + + private static final Logger logger = LoggerFactory.getLogger(MathUtils.class); + + /** + * 计算协方差 + * + * @param x 数据序列1 + * @param y 数据序列2 + * @param width 数据窗宽度 + * @return 协方差值 + */ + public static double covariance(double[] x, double[] y, int width) { + if (x == null || y == null || width <= 0) { + throw new IllegalArgumentException("Invalid input parameters for covariance calculation"); + } + + if (x.length < width || y.length < width) { + throw new IllegalArgumentException("Data length is less than window width"); + } + + double meanX = 0.0; + double meanY = 0.0; + + // 计算均值 + for (int i = 0; i < width; i++) { + meanX += x[i]; + meanY += y[i]; + } + meanX /= width; + meanY /= width; + + // 计算协方差 + double cov = 0.0; + for (int i = 0; i < width; i++) { + cov += (x[i] - meanX) * (y[i] - meanY); + } + + return cov / (width - 1); + } + + /** + * 计算协方差（float版本） + */ + public static float covariance(float[] x, float[] y, int width) { + double[] dx = new double[x.length]; + double[] dy = new double[y.length]; + for (int i = 0; i < x.length; i++) dx[i] = x[i]; + for (int i = 0; i < y.length; i++) dy[i] = y[i]; + return (float) covariance(dx, dy, width); + } + + /** + * 计算Pearson相关系数 + * + * @param x 数据序列1 + * @param y 数据序列2 + * @param count 数据长度 + * @return Pearson相关系数 + */ + public static double pearsonCorrelation(double[] x, double[] y, int count) { + if (x == null || y == null || count <= 0) { + throw new IllegalArgumentException("Invalid input parameters for Pearson correlation"); + } + + double meanX = 0.0; + double meanY = 0.0; + + // 计算均值 + for (int i = 0; i < count; i++) { + meanX += x[i]; + meanY += y[i]; + } + meanX /= count; + meanY /= count; + + // 计算相关系数的各个部分 + double numerator = 0.0; + double denomX = 0.0; + double denomY = 0.0; + + for (int i = 0; i < count; i++) { + double dx = x[i] - meanX; + double dy = y[i] - meanY; + numerator += dx * dy; + denomX += dx * dx; + denomY += dy * dy; + } + + double denominator = Math.sqrt(denomX * denomY); + + if (Math.abs(denominator) < HarmonicConstants.EPSILON) { + logger.warn("Denominator is too small in Pearson correlation calculation"); + return 0.0; + } + + return numerator / denominator; + } + + /** + * 计算Pearson相关系数（float版本） + */ + public static float pearsonCorrelation(float[] x, float[] y, int count) { + double[] dx = new double[count]; + double[] dy = new double[count]; + for (int i = 0; i < count; i++) { + dx[i] = x[i]; + dy[i] = y[i]; + } + return (float) pearsonCorrelation(dx, dy, count); + } + + /** + * 计算协方差矩阵（SXX） + * + * @param data 数据矩阵 [时间][节点] + * @param width 窗口宽度 + * @param nodeCount 节点数 + * @return 协方差矩阵 + */ + public static double[][] covarianceMatrix(double[][] data, int width, int nodeCount) { + double[][] covMatrix = new double[nodeCount][nodeCount]; + + for (int i = 0; i < nodeCount; i++) { + for (int j = 0; j < nodeCount; j++) { + double[] col1 = new double[width]; + double[] col2 = new double[width]; + + for (int k = 0; k < width; k++) { + col1[k] = data[k][i]; + col2[k] = data[k][j]; + } + + covMatrix[i][j] = covariance(col1, col2, width); + } + } + + return covMatrix; + } + + /** + * 计算协方差矩阵（float版本） + */ + public static float[][] covarianceMatrix(float[][] data, int width, int nodeCount) { + float[][] covMatrix = new float[nodeCount][nodeCount]; + + for (int i = 0; i < nodeCount; i++) { + for (int j = 0; j < nodeCount; j++) { + float[] col1 = new float[width]; + float[] col2 = new float[width]; + + for (int k = 0; k < width; k++) { + col1[k] = data[k][i]; + col2[k] = data[k][j]; + } + + covMatrix[i][j] = covariance(col1, col2, width); + } + } + + return covMatrix; + } + + /** + * 计算协方差向量（SXY） + * + * @param data 数据矩阵 [时间][节点] + * @param y 目标向量 + * @param width 窗口宽度 + * @param nodeCount 节点数 + * @return 协方差向量 + */ + public static double[] covarianceVector(double[][] data, double[] y, int width, int nodeCount) { + double[] covVector = new double[nodeCount]; + + for (int i = 0; i < nodeCount; i++) { + double[] col = new double[width]; + for (int k = 0; k < width; k++) { + col[k] = data[k][i]; + } + covVector[i] = covariance(col, y, width); + } + + return covVector; + } + + /** + * 计算协方差向量（float版本） + */ + public static float[] covarianceVector(float[][] data, float[] y, int width, int nodeCount) { + float[] covVector = new float[nodeCount]; + + for (int i = 0; i < nodeCount; i++) { + float[] col = new float[width]; + for (int k = 0; k < width; k++) { + col[k] = data[k][i]; + } + covVector[i] = covariance(col, y, width); + } + + return covVector; + } + + /** + * 矩阵求逆 + * 使用Apache Commons Math库 + * + * @param matrix 输入矩阵 + * @return 逆矩阵 + */ + public static double[][] matrixInverse(double[][] matrix) { + RealMatrix realMatrix = new Array2DRowRealMatrix(matrix); + + try { + // 使用LU分解求逆 + DecompositionSolver solver = new LUDecomposition(realMatrix).getSolver(); + RealMatrix inverseMatrix = solver.getInverse(); + return inverseMatrix.getData(); + } catch (SingularMatrixException e) { + logger.error("Matrix is singular, cannot compute inverse", e); + throw new RuntimeException("Matrix inversion failed: singular matrix"); + } + } + + /** + * 计算矩阵的特征值 + * + * @param matrix 输入矩阵 + * @return 特征值数组 + */ + public static double[] eigenvalues(double[][] matrix) { + RealMatrix realMatrix = new Array2DRowRealMatrix(matrix); + EigenDecomposition eigenDecomposition = new EigenDecomposition(realMatrix); + return eigenDecomposition.getRealEigenvalues(); + } + + /** + * 归一化处理 + * 将数据归一化到[0,1]区间 + * + * @param data 输入数据 + * @return 归一化后的数据 + */ + public static double[] normalize(double[] data) { + if (data == null || data.length == 0) { + return data; + } + + double min = Double.MAX_VALUE; + double max = Double.MIN_VALUE; + + // 找最大最小值 + for (double value : data) { + min = Math.min(min, value); + max = Math.max(max, value); + } + + double range = max - min; + if (Math.abs(range) < HarmonicConstants.EPSILON) { + return new double[data.length]; // 返回全0数组 + } + + double[] normalized = new double[data.length]; + for (int i = 0; i < data.length; i++) { + normalized[i] = (data[i] - min) / range; + } + + return normalized; + } + + /** + * 数据对齐处理 + * 将不同采样间隔的数据对齐到相同的时间间隔 + * + * @param data 原始数据 + * @param originalInterval 原始采样间隔 + * @param targetInterval 目标采样间隔 + * @return 对齐后的数据 + */ + public static float[] alignData(float[] data, int originalInterval, int targetInterval) { + if (targetInterval % originalInterval != 0) { + throw new IllegalArgumentException( + "Target interval must be multiple of original interval"); + } + + int ratio = targetInterval / originalInterval; + int newLength = data.length / ratio; + float[] alignedData = new float[newLength]; + + for (int i = 0; i < newLength; i++) { + float sum = 0; + for (int j = 0; j < ratio; j++) { + sum += data[i * ratio + j]; + } + alignedData[i] = sum / ratio; + } + + return alignedData; + } +} \ No newline at end of file diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/IRespDataService.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/IRespDataService.java index d02d0a8ef..5459cce31 100644 --- a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/IRespDataService.java +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/IRespDataService.java @@ -21,8 +21,12 @@ import java.util.List; */ public interface IRespDataService extends IService { + ResponsibilityResult getDynamicDataOld(ResponsibilityCalculateParam responsibilityCalculateParam); + ResponsibilityResult getDynamicData(ResponsibilityCalculateParam responsibilityCalculateParam); + ResponsibilityResult getResponsibilityDataOld(ResponsibilitySecondCalParam responsibilitySecondCalParam); + ResponsibilityResult getResponsibilityData(ResponsibilitySecondCalParam responsibilitySecondCalParam); Page responsibilityList(BaseParam queryParam); diff --git a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/impl/RespDataServiceImpl.java b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/impl/RespDataServiceImpl.java index 8f2556040..b3a2b4869 100644 --- a/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/impl/RespDataServiceImpl.java +++ b/pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/responsibility/impl/RespDataServiceImpl.java @@ -27,6 +27,9 @@ import com.njcn.advance.pojo.param.ResponsibilityCalculateParam; import com.njcn.advance.pojo.param.ResponsibilitySecondCalParam; import com.njcn.advance.pojo.po.responsibility.RespData; import com.njcn.advance.pojo.po.responsibility.RespDataResult; +import com.njcn.advance.responsibility.constant.CalculationStatus; +import com.njcn.advance.responsibility.model.HarmonicData; +import com.njcn.advance.responsibility.service.IHarmonicResponsibilityService; import com.njcn.advance.service.responsibility.IRespDataResultService; import com.njcn.advance.service.responsibility.IRespDataService; import com.njcn.advance.service.responsibility.IRespUserDataService; @@ -91,6 +94,8 @@ public class RespDataServiceImpl extends ServiceImpl i private final CommTerminalGeneralClient commTerminalGeneralClient; + private final IHarmonicResponsibilityService harmonicResponsibilityService; + public final static int SORT_10 = 10; public final static int INTERVAL_TIME_1 = 1; public final static int INTERVAL_TIME_3 = 3; @@ -161,7 +166,8 @@ public class RespDataServiceImpl extends ServiceImpl i @Override - public ResponsibilityResult getDynamicData(ResponsibilityCalculateParam responsibilityCalculateParam) { + @Deprecated + public ResponsibilityResult getDynamicDataOld(ResponsibilityCalculateParam responsibilityCalculateParam) { ResponsibilityResult result = new ResponsibilityResult(); //调用c++依赖需要待初始化的参数 int pNode, pNum, win, harmNum; @@ -419,7 +425,268 @@ public class RespDataServiceImpl extends ServiceImpl i } @Override - public ResponsibilityResult getResponsibilityData(ResponsibilitySecondCalParam responsibilitySecondCalParam) { + public ResponsibilityResult getDynamicData(ResponsibilityCalculateParam responsibilityCalculateParam) { + ResponsibilityResult result = new ResponsibilityResult(); + //调用c++依赖需要待初始化的参数 + int pNode, pNum, win, harmNum; + float harmMk; + List userDataExcels = respUserDataService.getUserDataExcelList(responsibilityCalculateParam.getUserDataId()); + //开始处理，根据接口参数需求，需要节点数（用户数，用户名+监测点号为一个用户），时间范围内功率数据 + DealDataResult dealDataResult = RespUserDataServiceImpl.getStanderData(userDataExcels, 1); + List dateStr = PubUtils.getTimes(DateUtil.parse(responsibilityCalculateParam.getSearchBeginTime(), DatePattern.NORM_DATE_PATTERN), DateUtil.parse(responsibilityCalculateParam.getSearchEndTime(), DatePattern.NORM_DATE_PATTERN)); + Map>> finalData = getFinalUserData(dealDataResult, dateStr); + //至此，finalData便是我们最终获得的用于计算责任数据,第一个参数节点数值pNode获取到 + //第一个参数pNode + pNode = finalData.size(); + if (pNode < 1) { + //没有合理的用采数据直接返回 + throw new BusinessException(AdvanceResponseEnum.USER_DATA_P_NODE_PARAMETER_ERROR); + } + //第二个参数pNum，根据起始时间和截止时间以及监测点测量间隔计算数量 + RespCommon pNumAndInterval = getPNumAndInterval(finalData, responsibilityCalculateParam.getLineId(), dateStr); + pNum = pNumAndInterval.getPNum(); + int userIntervalTime = pNumAndInterval.getUserIntervalTime(); + int lineInterval = pNumAndInterval.getLineInterval(); + //第三个参数win,根据起始时间和截止时间的间隔 + if (dateStr.size() > 1) { + if (userIntervalTime == INTERVAL_TIME_15) { + win = WINDOW_96; + } else { + win = WINDOW_48; + } + } else { + win = WINDOW_4; + } + //第四个参数harmMk，默认为0f + harmMk = 0f; + //第五个参数harmNum，与功率数据保持一致 + harmNum = pNum; + //至此基础数据组装完毕，开始组装功率数据和谐波数据 + //先做谐波数据，理论上到这步的时候，谐波数据是满足完整性并已经补充完整性到100%，此处需要将谐波数据与功率数据长度匹配上 + RespHarmData respHarmData = getRespHarmData(responsibilityCalculateParam, lineInterval); + //harmData填充完毕后，开始组装功率数据 + //首先获取当前时间内的各个用户的数据 + Map> originalPData = new HashMap<>(16); + List names = new ArrayList<>(); + Set userNamesFinal = finalData.keySet(); + for (String userName : userNamesFinal) { + List tempData = new ArrayList<>(); + //根据日期将日期数据全部获取出来z + Map> tempResult = finalData.get(userName); + for (String date : dateStr) { + tempData.addAll(tempResult.get(date)); + } + //按日期排序 + Collections.sort(tempData); + originalPData.put(userName, tempData); + names.add(userName); + } + //然后开始组装数据 + float[][] pData = new float[QvvrDataEntity.MAX_P_NUM][QvvrDataEntity.MAX_P_NODE]; + for (int i = 0; i < names.size(); i++) { + //当前某用户测量节点的所有数据 + List userDataExcelBodies1 = originalPData.get(names.get(i)); + for (int k = 0; k < userDataExcelBodies1.size(); k++) { + float[] pDataStruct = pData[k]; + if (pDataStruct == null) { + pDataStruct = new float[QvvrDataEntity.MAX_P_NODE]; + } + float[] p = pDataStruct; + p[i] = userDataExcelBodies1.get(k).getWork().floatValue(); + pData[k] = pDataStruct; + } + } + //至此功率数据也组装完毕，调用友谊提供的接口 +// QvvrDataEntity qvvrDataEntity = new QvvrDataEntity(); +// qvvrDataEntity.calFlag = 0; +// qvvrDataEntity.pNode = pNode; +// qvvrDataEntity.pNum = pNum; +// qvvrDataEntity.win = win; +// qvvrDataEntity.harmNum = harmNum; +// qvvrDataEntity.harmMk = harmMk; +// qvvrDataEntity.pData = pData; +// qvvrDataEntity.harmData = respHarmData.getHarmData(); +// ResponsibilityAlgorithm responsibilityAlgorithm = new ResponsibilityAlgorithm(); +// qvvrDataEntity = responsibilityAlgorithm.getResponsibilityResult(qvvrDataEntity); + + HarmonicData harmonicData = harmonicResponsibilityService.fullCalculation(respHarmData.getHarmData(), pData, harmNum, pNum, pNode, win, harmMk); + //至此接口调用结束，开始组装动态责任数据和用户责任量化结果 + //首先判断cal_ok的标识位是否为1，为0表示程序没有计算出结果 + if (harmonicData.getCalculationStatus() == CalculationStatus.FAILED) { + throw new BusinessException(AdvanceResponseEnum.RESPONSIBILITY_PARAMETER_ERROR); + } + //没问题后，先玩动态责任数据 + CustomerData[] customerDatas = new CustomerData[harmonicData.getPowerNodeCount()]; + float[][] fKdata/*无背景的动态责任数据*/ = harmonicData.getFkData(); + //第一个时间节点是起始时间+win窗口得到的时间 + Date sTime = DateUtil.parse(dateStr.get(0).concat(" 00:00:00"), DatePattern.NORM_DATETIME_PATTERN); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(sTime); + calendar.add(Calendar.MINUTE, (win - 1) * userIntervalTime); + List timeDatas = new ArrayList<>(); + for (int i = 0; i < harmonicData.getPowerCount() - harmonicData.getWindowSize(); i++) { + calendar.add(Calendar.MINUTE, userIntervalTime); + //一个时间点所有的用户数据 + float[] fKdatum = fKdata[i]; + for (int k = 0; k < harmonicData.getPowerNodeCount(); k++) { + CustomerData customerData = customerDatas[k]; + if (null == customerData) { + customerData = new CustomerData(); + customerData.setCustomerName(names.get(k)); + } + List valueDatas = customerData.getValueDatas(); + Float valueTemp = fKdatum[k]; + if (valueTemp.isNaN()) { + valueTemp = 0.0f; + } + valueDatas.add(valueTemp); + customerData.setValueDatas(valueDatas); + customerDatas[k] = customerData; + } + timeDatas.add(calendar.getTimeInMillis()); + } + //OK拿到所有测量点的数据了，现在就是看如何将相同户号的动态数据进行算术和求值，之前的用户name为：户号@测量点号@用户名 + Map> customerDataTemp = new HashMap<>(16); + for (CustomerData data : customerDatas) { + String customerName = data.getCustomerName(); + String[] customerInfo = customerName.split("@"); + String name = customerInfo[2] + "(" + customerInfo[0] + ")"; + List customerData = customerDataTemp.get(name); + CustomerData temp = data; + temp.setCustomerName(name); + if (CollectionUtils.isEmpty(customerData)) { + customerData = new ArrayList<>(); + } + customerData.add(temp); + customerDataTemp.put(name, customerData); + } + //动态数据组装完成后，开始组装责任数据 + List customerResponsibilities = getCustomerResponsibilityData(names, harmonicData.getSumFKData(), harmonicData.getPowerNodeCount()); + //根据前十的用户数据，获取这些用户的动态责任数据 + List customerData = new ArrayList<>(); + for (CustomerResponsibility customerResponsibility : customerResponsibilities) { + String cusName = customerResponsibility.getCustomerName(); + List customerData1 = customerDataTemp.get(cusName); + if (CollectionUtils.isEmpty(customerData1)) { + continue; + } + if (customerData1.size() == 1) { + //表示用户唯一的 + customerData.add(customerData1.get(0)); + } else { + // 表示用户可能包含多个监测点号，需要进行数据累加 + CustomerData customerDataT = new CustomerData(); + customerDataT.setCustomerName(cusName); + //进行数值累加 + List valueDatas = new ArrayList<>(); + for (int i = 0; i < customerData1.get(0).getValueDatas().size(); i++) { + float original = 0.0f; + for (CustomerData data : customerData1) { + original = original + data.getValueDatas().get(i); + } + valueDatas.add(original); + } + customerDataT.setValueDatas(valueDatas); + customerData.add(customerDataT); + } + } + result.setDatas(customerData); + result.setTimeDatas(timeDatas); + result.setResponsibilities(customerResponsibilities); + //此次的操作进行入库操作responsibilityData表数据 + //根据监测点名称+谐波框选的时间来查询，是否做过责任量化 + String timeWin = responsibilityCalculateParam.getSearchBeginTime().replaceAll(StrPool.DASHED, "").concat(StrPool.DASHED).concat(responsibilityCalculateParam.getSearchEndTime().replaceAll(StrPool.DASHED, "")); + String type = responsibilityCalculateParam.getType() == 0 ? "谐波电流" : "谐波电压"; + //为了避免有监测点名称重复的，最终还是选择使用监测点索引来判断唯一性 + LambdaQueryWrapper respDataLambdaQueryWrapper = new LambdaQueryWrapper<>(); + respDataLambdaQueryWrapper.eq(RespData::getLineId, responsibilityCalculateParam.getLineId()) + .eq(RespData::getUserDataId, responsibilityCalculateParam.getUserDataId()) + .eq(RespData::getTimeWindow, timeWin) + .eq(RespData::getDataType, type) + .eq(RespData::getState, DataStateEnum.ENABLE.getCode()); + List responsibilityDataTemp = this.baseMapper.selectList(respDataLambdaQueryWrapper); + RespData responsibilityData; + if (CollectionUtils.isEmpty(responsibilityDataTemp)) { + responsibilityData = new RespData(); + //库中没有记录则可以新建数据进行插入 + responsibilityData.setLineId(responsibilityCalculateParam.getLineId()); + responsibilityData.setUserDataId(responsibilityCalculateParam.getUserDataId()); + responsibilityData.setDataType(type); + responsibilityData.setDataTimes(responsibilityCalculateParam.getTime().toString()); + responsibilityData.setTimeWindow(timeWin); + responsibilityData.setState(DataStateEnum.ENABLE.getCode()); + //进行插入操作 + this.baseMapper.insert(responsibilityData); + } else { + //库中存在记录只需要判断次数进行数据更新 + responsibilityData = responsibilityDataTemp.get(0); + String times = responsibilityData.getDataTimes(); + List timesList = Stream.of(times.split(StrPool.COMMA)).collect(Collectors.toList()); + Integer time = responsibilityCalculateParam.getTime(); + if (!timesList.contains(time.toString())) { + timesList.add(time.toString()); + timesList = timesList.stream().sorted().collect(Collectors.toList()); + responsibilityData.setDataTimes(String.join(StrPool.COMMA, timesList)); + } + //执行更新操作 + this.baseMapper.updateById(responsibilityData); + } + //入库完毕之后，需要将必要数据进行序列化存储，方便后期的重复利用 + /* + * 需要序列化三种数据结构 1 cal_flag置为1时需要的一些列参数的CacheQvvrData 2 cal_flag为0时的，动态结果。3 用户责任量化结果 + * 其中1/2都只需要一个文件即可 + * 3因为用户限值的变化调整，可能存在很多个文件，具体根据用户的选择而定 + * + * 路径的结构为，temPath+userData+excelName+type+timeWin+lineIndex+time+文件名 + * 用户责任量化结果，需要再细化到限值 + */ + //首先判断有没有存储记录，没有则存储，有就略过 指定测点、时间窗口、谐波类型、谐波次数判断唯一性 + LambdaQueryWrapper respDataResultLambdaQueryWrapper = new LambdaQueryWrapper<>(); + respDataResultLambdaQueryWrapper.eq(RespDataResult::getResDataId, responsibilityData.getId()) + .eq(RespDataResult::getTime, responsibilityCalculateParam.getTime()) + .eq(RespDataResult::getStartTime, DateUtil.parse(responsibilityCalculateParam.getSearchBeginTime() + " 00:00:00", DatePattern.NORM_DATETIME_PATTERN)) + .eq(RespDataResult::getEndTime, DateUtil.parse(responsibilityCalculateParam.getSearchEndTime() + " 23:59:59", DatePattern.NORM_DATETIME_PATTERN)) + .eq(RespDataResult::getLimitValue, respHarmData.getOverLimit()); + RespDataResult respDataResult = respDataResultService.getOne(respDataResultLambdaQueryWrapper); + if (Objects.isNull(respDataResult)) { + respDataResult = new RespDataResult(); + respDataResult.setResDataId(responsibilityData.getId()); + respDataResult.setTime(responsibilityCalculateParam.getTime()); + respDataResult.setStartTime(DateUtil.parse(responsibilityCalculateParam.getSearchBeginTime() + " 00:00:00", DatePattern.NORM_DATETIME_PATTERN)); + respDataResult.setEndTime(DateUtil.parse(responsibilityCalculateParam.getSearchEndTime() + " 23:59:59", DatePattern.NORM_DATETIME_PATTERN)); + respDataResult.setLimitValue(respHarmData.getOverLimit()); + //时间横轴数据 timeDatas + JSONArray timeDataJson = JSONArray.parseArray(JSON.toJSONString(timeDatas)); + InputStream timeDataStream = IoUtil.toUtf8Stream(timeDataJson.toString()); + String timeDataPath = fileStorageUtil.uploadStream(timeDataStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setTimeData(timeDataPath); + //用户每时刻对应的责任数据 + JSONArray customerDataJson = JSONArray.parseArray(JSON.toJSONString(customerData)); + InputStream customerStream = IoUtil.toUtf8Stream(customerDataJson.toString()); + String customerPath = fileStorageUtil.uploadStream(customerStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setUserDetailData(customerPath); + //调用qvvr生成的中间数据 + CacheQvvrData cacheQvvrData = new CacheQvvrData(harmonicData.getPowerNodeCount(), harmonicData.getHarmonicCount(), harmonicData.getHarmonicData(), harmonicData.getFkData(), harmonicData.getHkData(), names, userIntervalTime, harmonicData.getWindowSize(), userIntervalTime, respHarmData.getHarmTime()); + String cacheJson = PubUtils.obj2json(cacheQvvrData); + InputStream cacheQvvrDataStream = IoUtil.toUtf8Stream(cacheJson); + String cacheQvvrDataPath = fileStorageUtil.uploadStream(cacheQvvrDataStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setQvvrData(cacheQvvrDataPath); + //用户前10数据存储 + JSONArray customerResJson = JSONArray.parseArray(JSON.toJSONString(customerResponsibilities)); + InputStream customerResStream = IoUtil.toUtf8Stream(customerResJson.toString()); + String customerResPath = fileStorageUtil.uploadStream(customerResStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setUserResponsibility(customerResPath); + respDataResultService.save(respDataResult); + } + //防止过程中创建了大量的对象，主动调用下GC处理 + System.gc(); + result.setResponsibilityDataIndex(responsibilityData.getId()); + return result; + } + + @Override + @Deprecated + public ResponsibilityResult getResponsibilityDataOld(ResponsibilitySecondCalParam responsibilitySecondCalParam) { ResponsibilityResult result = new ResponsibilityResult(); //根据时间天数，获取理论上多少次用采数据 RespData responsibilityData = this.baseMapper.selectById(responsibilitySecondCalParam.getResDataId()); @@ -664,6 +931,258 @@ public class RespDataServiceImpl extends ServiceImpl i return result; } + @Override + public ResponsibilityResult getResponsibilityData(ResponsibilitySecondCalParam responsibilitySecondCalParam) { + ResponsibilityResult result = new ResponsibilityResult(); + //根据时间天数，获取理论上多少次用采数据 + RespData responsibilityData = this.baseMapper.selectById(responsibilitySecondCalParam.getResDataId()); + if (Objects.isNull(responsibilityData)) { + throw new BusinessException(AdvanceResponseEnum.RESP_DATA_NOT_FOUND); + } + Overlimit overlimit = lineFeignClient.getOverLimitData(responsibilityData.getLineId()).getData(); + //获取总数据 + LambdaQueryWrapper respDataResultLambdaQueryWrapper = new LambdaQueryWrapper<>(); + respDataResultLambdaQueryWrapper.eq(RespDataResult::getResDataId, responsibilityData.getId()) + .eq(RespDataResult::getTime, responsibilitySecondCalParam.getTime()); + if (responsibilitySecondCalParam.getType() == 0) { + respDataResultLambdaQueryWrapper.eq(RespDataResult::getLimitValue, PubUtils.getValueByMethod(overlimit, "getIharm", responsibilitySecondCalParam.getTime())); + } else { + respDataResultLambdaQueryWrapper.eq(RespDataResult::getLimitValue, PubUtils.getValueByMethod(overlimit, "getUharm", responsibilitySecondCalParam.getTime())); + } + RespDataResult respDataResultTemp = respDataResultService.getOne(respDataResultLambdaQueryWrapper); + if (Objects.isNull(respDataResultTemp)) { + throw new BusinessException(AdvanceResponseEnum.RESP_DATA_NOT_FOUND); + } + CacheQvvrData cacheQvvrData; + try { + InputStream fileStream = fileStorageUtil.getFileStream(respDataResultTemp.getQvvrData()); + String qvvrDataStr = IoUtil.readUtf8(fileStream); + cacheQvvrData = PubUtils.json2obj(qvvrDataStr, CacheQvvrData.class); + + } catch (Exception exception) { + throw new BusinessException(AdvanceResponseEnum.RESP_RESULT_DATA_NOT_FOUND); + } + //获取成功后，延长该缓存的生命周期为初始生命时长 + int win = cacheQvvrData.getWin(); + //不管窗口为4或者96，都需要考虑最小公倍数 + //最小公倍数根据监测点测量间隔来获取，可以考虑也由第一步操作缓存起来 + int minMultiple = cacheQvvrData.getMinMultiple(); + //谐波横轴所有的时间 + List times = cacheQvvrData.getTimes(); + //首先根据窗口判断限值时间范围是否满足最小窗口 + Long limitSL = DateUtil.parse(responsibilitySecondCalParam.getLimitStartTime(), DatePattern.NORM_DATETIME_PATTERN).getTime(); + Long limitEL = DateUtil.parse(responsibilitySecondCalParam.getLimitEndTime(), DatePattern.NORM_DATETIME_PATTERN).getTime(); + List temp = getTimes(times, limitSL, limitEL); + //在动态责任数据中，时间的起始索引位置和截止索引位置 + Integer timeStartIndex = temp.get(0); + Integer timeEndIndex = temp.get(1); + //间隔中的时间长度 + int minus = timeEndIndex - timeStartIndex + 1; + //组装参数 + QvvrDataEntity qvvrDataEntity = new QvvrDataEntity(); + qvvrDataEntity.calFlag = 1; + qvvrDataEntity.pNode = cacheQvvrData.getPNode(); + qvvrDataEntity.harmMk = responsibilitySecondCalParam.getLimitValue(); + qvvrDataEntity.win = win; + int resNum; + float[][] FKdata = new float[9600][QvvrDataEntity.MAX_P_NODE]; + float[][] HKdata = new float[9600][QvvrDataEntity.MAX_P_NODE + 1]; + float[] harmData = new float[1440 * 100]; + float[][] fKdataOriginal = cacheQvvrData.getFKData(); + float[][] hKdataOriginal = cacheQvvrData.getHKData(); + float[] harmDataOriginal = cacheQvvrData.getHarmData(); + //如果起始索引与截止索引的差值等于时间轴的长度，则说明用户没有选择限值时间，直接带入全部的原始数据，参与计算即可 + if (minus == times.size()) { + qvvrDataEntity.harmNum = cacheQvvrData.getHarmNum(); + qvvrDataEntity.resNum = cacheQvvrData.getHarmNum() - cacheQvvrData.getWin(); + qvvrDataEntity.setFKData(cacheQvvrData.getFKData()); + qvvrDataEntity.setHKData(cacheQvvrData.getHKData()); + qvvrDataEntity.harmData = cacheQvvrData.getHarmData(); + } else { + if (win == WINDOW_4) { + //当窗口为4时,两个时间限制范围在最小公倍数为15时，最起码有5个有效时间点，在最小公倍数为30时，最起码有3个有效时间点 + if (minMultiple == INTERVAL_TIME_15) { + if (minus < MINUS_5) { + throw new BusinessException(AdvanceResponseEnum.WIN_TIME_ERROR); + } + resNum = minus - MINUS_4; + + } else if (minMultiple == INTERVAL_TIME_30) { + if (minus < MINUS_3) { + throw new BusinessException(AdvanceResponseEnum.WIN_TIME_ERROR); + } + resNum = minus - MINUS_2; + } else { + throw new BusinessException(AdvanceResponseEnum.CALCULATE_INTERVAL_ERROR); + } + } else if (win == WINDOW_96) { + //当窗口为96时,两个时间限值范围在最小公倍数为15时，最起码有97个有效时间点，在最小公倍数为30时，最起码有49个有效时间点 + if (minMultiple == INTERVAL_TIME_15) { + if (minus <= WINDOW_96) { + throw new BusinessException(AdvanceResponseEnum.WIN_TIME_ERROR); + } + resNum = minus - WINDOW_96; + } else if (minMultiple == INTERVAL_TIME_30) { + if (minus <= WINDOW_48) { + throw new BusinessException(AdvanceResponseEnum.WIN_TIME_ERROR); + } + resNum = minus - WINDOW_48; + } else { + throw new BusinessException(AdvanceResponseEnum.CALCULATE_INTERVAL_ERROR); + } + } else { + throw new BusinessException(AdvanceResponseEnum.CALCULATE_INTERVAL_ERROR); + } + qvvrDataEntity.resNum = resNum; + qvvrDataEntity.harmNum = minus; + //因为限值时间实际是含头含尾的，所以harmNum需要索引差值+1 + for (int i = timeStartIndex; i <= timeEndIndex; i++) { + harmData[i - timeStartIndex] = harmDataOriginal[i]; + } + qvvrDataEntity.harmData = harmData; + //FKData与HKData的值则等于resNum + for (int i = timeStartIndex; i < timeStartIndex + resNum; i++) { + FKdata[i - timeStartIndex] = fKdataOriginal[i]; + HKdata[i - timeStartIndex] = hKdataOriginal[i]; + } + + qvvrDataEntity.setFKData(FKdata); + qvvrDataEntity.setHKData(HKdata); + } +// ResponsibilityAlgorithm responsibilityAlgorithm = new ResponsibilityAlgorithm(); +// qvvrDataEntity = responsibilityAlgorithm.getResponsibilityResult(qvvrDataEntity); +// +// if (qvvrDataEntity.calOk == 0) { +// throw new BusinessException(AdvanceResponseEnum.RESPONSIBILITY_PARAMETER_ERROR); +// } + HarmonicData harmonicData = harmonicResponsibilityService.partialCalculation( + qvvrDataEntity.getHarmData(), qvvrDataEntity.getFKData(), qvvrDataEntity.getHKData(), qvvrDataEntity.getHarmNum(), qvvrDataEntity.getPNode(), qvvrDataEntity.getWin(), qvvrDataEntity.getResNum(), qvvrDataEntity.getHarmMk()); + if (harmonicData.getCalculationStatus() == CalculationStatus.FAILED) { + throw new BusinessException(AdvanceResponseEnum.RESPONSIBILITY_PARAMETER_ERROR); + } + + //没问题后，先玩动态责任数据 + List names = cacheQvvrData.getNames(); + CustomerData[] customerDatas = new CustomerData[harmonicData.getPowerNodeCount()]; + float[][] fKdata/*无背景的动态责任数据*/ = harmonicData.getFkData(); + //第一个时间节点是起始时间+win窗口得到的时间 + Date sTime = new Date(); + sTime.setTime(times.get(timeStartIndex)); + Calendar calendar = Calendar.getInstance(); + calendar.setTime(sTime); + calendar.add(Calendar.MINUTE, (win - 1) * minMultiple); + List timeDatas = new ArrayList<>(); + for (int i = 0; i < harmonicData.getHarmonicCount() - harmonicData.getWindowSize(); i++) { + calendar.add(Calendar.MINUTE, minMultiple); + //一个时间点所有的用户数据 + float[] fKdatum = fKdata[i]; + for (int k = 0; k < harmonicData.getPowerNodeCount(); k++) { + CustomerData customerData = customerDatas[k]; + if (null == customerData) { + customerData = new CustomerData(); + customerData.setCustomerName(names.get(k)); + } + List valueDatas = customerData.getValueDatas(); + Float valueTemp = fKdatum[k]; + if (valueTemp.isNaN()) { + valueTemp = 0.0f; + } + valueDatas.add(valueTemp); + customerData.setValueDatas(valueDatas); + customerDatas[k] = customerData; + } + timeDatas.add(calendar.getTimeInMillis()); + } + //OK拿到所有测量点的数据了，现在就是看如何将相同户号的动态数据进行算术和求值，之前的用户name为：户号@测量点号@用户名 + Map> customerDataTemp = new HashMap<>(32); + for (CustomerData data : customerDatas) { + String customerName = data.getCustomerName(); + String[] customerInfo = customerName.split("@"); + String name = customerInfo[2] + "(" + customerInfo[0] + ")"; + List customerData = customerDataTemp.get(name); + CustomerData customerTemp = data; + customerTemp.setCustomerName(name); + if (CollectionUtils.isEmpty(customerData)) { + customerData = new ArrayList<>(); + } + customerData.add(customerTemp); + customerDataTemp.put(name, customerData); + } + //调用程序接口后，首先组装责任量化结果 + float[] sumFKdata = harmonicData.getSumFKData(); + List customerResponsibilities = getCustomerResponsibilityData(names, sumFKdata, harmonicData.getPowerNodeCount()); + //根据前十的用户数据，获取这些用户的动态责任数据 + List customerData = new ArrayList<>(); + + for (CustomerResponsibility customerResponsibility : customerResponsibilities) { + String cusName = customerResponsibility.getCustomerName(); + List customerData1 = customerDataTemp.get(cusName); + if (CollectionUtils.isEmpty(customerData1)) { + continue; + } + if (customerData1.size() == 1) { + //表示用户唯一的 + customerData.add(customerData1.get(0)); + } else { + // 表示用户可能包含多个监测点号，需要进行数据累加 + CustomerData customerDataT = new CustomerData(); + customerDataT.setCustomerName(cusName); + //进行数值累加 + List valueDatas = new ArrayList<>(); + for (int i = 0; i < customerData1.get(0).getValueDatas().size(); i++) { + float original = 0.0f; + for (CustomerData data : customerData1) { + original = original + data.getValueDatas().get(i); + } + valueDatas.add(original); + } + customerDataT.setValueDatas(valueDatas); + customerData.add(customerDataT); + } + } + //接着组装动态数据结果 + result.setResponsibilities(customerResponsibilities); + result.setDatas(customerData); + result.setTimeDatas(timeDatas); + + //首先判断有没有存储记录，没有则存储，有就略过 指定测点、时间窗口、谐波类型、谐波次数判断唯一性 + LambdaQueryWrapper respDataResultLambdaQueryWrapper1 = new LambdaQueryWrapper<>(); + respDataResultLambdaQueryWrapper1.eq(RespDataResult::getResDataId, responsibilityData.getId()) + .eq(RespDataResult::getTime, responsibilitySecondCalParam.getTime()) + .eq(RespDataResult::getStartTime, DateUtil.parse(responsibilitySecondCalParam.getLimitStartTime(), DatePattern.NORM_DATETIME_PATTERN)) + .eq(RespDataResult::getEndTime, DateUtil.parse(responsibilitySecondCalParam.getLimitEndTime(), DatePattern.NORM_DATETIME_PATTERN)) + .eq(RespDataResult::getLimitValue, responsibilitySecondCalParam.getLimitValue()); + RespDataResult respDataResult = respDataResultService.getOne(respDataResultLambdaQueryWrapper1); + if (Objects.isNull(respDataResult)) { + respDataResult = new RespDataResult(); + respDataResult.setResDataId(responsibilityData.getId()); + respDataResult.setTime(responsibilitySecondCalParam.getTime()); + respDataResult.setStartTime(DateUtil.parse(responsibilitySecondCalParam.getLimitStartTime(), DatePattern.NORM_DATETIME_PATTERN)); + respDataResult.setEndTime(DateUtil.parse(responsibilitySecondCalParam.getLimitEndTime(), DatePattern.NORM_DATETIME_PATTERN)); + respDataResult.setLimitValue(responsibilitySecondCalParam.getLimitValue()); + //时间横轴数据 timeDatas + JSONArray timeDataJson = JSONArray.parseArray(JSON.toJSONString(timeDatas)); + InputStream timeDataStream = IoUtil.toUtf8Stream(timeDataJson.toString()); + String timeDataPath = fileStorageUtil.uploadStream(timeDataStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setTimeData(timeDataPath); + //用户每时刻对应的责任数据 + JSONArray customerDataJson = JSONArray.parseArray(JSON.toJSONString(customerData)); + InputStream customerStream = IoUtil.toUtf8Stream(customerDataJson.toString()); + String customerPath = fileStorageUtil.uploadStream(customerStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setUserDetailData(customerPath); + //用户前10数据存储 + JSONArray customerResJson = JSONArray.parseArray(JSON.toJSONString(customerResponsibilities)); + InputStream customerResStream = IoUtil.toUtf8Stream(customerResJson.toString()); + String customerResPath = fileStorageUtil.uploadStream(customerResStream, OssPath.RESPONSIBILITY_USER_RESULT_DATA, FileUtil.generateFileName("json")); + respDataResult.setUserResponsibility(customerResPath); + respDataResultService.save(respDataResult); + } + //防止过程中创建了大量的对象，主动调用下GC处理 + System.gc(); + result.setResponsibilityDataIndex(responsibilityData.getId()); + return result; + } + /** * 监测点测量间隔获取最后用于计算的功率数据