1、暂降原因（java实现）；
2、暂降类型（JNA调用）；
This commit is contained in:
@@ -79,6 +79,21 @@
|
||||
<version>5.5.0</version>
|
||||
</dependency>
|
||||
|
||||
<!--暂降原因所需的依赖-->
|
||||
<!-- Apache Commons Math for FFT and mathematical functions -->
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-math3</artifactId>
|
||||
<version>3.6.1</version>
|
||||
</dependency>
|
||||
|
||||
<!-- EJML for matrix operations and SVD -->
|
||||
<dependency>
|
||||
<groupId>org.ejml</groupId>
|
||||
<artifactId>ejml-simple</artifactId>
|
||||
<version>0.41</version>
|
||||
</dependency>
|
||||
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
package com.njcn.advance.event.cause.algorithm;
|
||||
|
||||
|
||||
import com.njcn.advance.event.cause.model.VecStruct;
|
||||
|
||||
/**
|
||||
* DQ变换算法实现
|
||||
* 对应C语言中的dq_delay.c文件
|
||||
*/
|
||||
public class DQTransform {
|
||||
private static final double PI = Math.PI;
|
||||
|
||||
/**
|
||||
* DQ变换延时处理
|
||||
* @param Va A相电压数组
|
||||
* @param t 时间数组
|
||||
* @param samplePoint 一个周期的采样点数
|
||||
* @param n 数据个数
|
||||
* @param f 频率
|
||||
* @param ua 输出幅值数组
|
||||
* @param angleUa 输出相角数组
|
||||
* @param vecU 输出相量数组
|
||||
*/
|
||||
public static void dqDelay(float[] Va, float[] t, int samplePoint, int n, float f,
|
||||
float[] ua, float[] angleUa, VecStruct[] vecU) {
|
||||
|
||||
int delay = (int) (samplePoint / 6.0 + 0.5); // 延时量实际是超前60°
|
||||
float ang = (float) delay / samplePoint;
|
||||
|
||||
float[] upd1 = new float[n];
|
||||
float[] upq1 = new float[n];
|
||||
float[] upd = new float[n];
|
||||
float[] upq = new float[n];
|
||||
|
||||
// 延时计算dq变换
|
||||
for (int i = delay; i < n; i++) {
|
||||
float Vo = Va[i - delay];
|
||||
float Vc = -(1.0f / 2.0f) * Va[i] +
|
||||
(float) (Math.sqrt(3) / 2.0) *
|
||||
(Va[i] * (float) Math.cos(ang * 2 * PI) - Vo) /
|
||||
(float) Math.sin(ang * 2 * PI);
|
||||
float Vb = -Va[i] - Vc;
|
||||
|
||||
DQResult result = dqTransform(Va[i], Vb, Vc, t[i], f);
|
||||
upd1[i] = result.upd;
|
||||
upq1[i] = result.upq;
|
||||
}
|
||||
|
||||
// 延时段缺失值用第一个有效值填充
|
||||
for (int i = 0; i < delay; i++) {
|
||||
upd1[i] = upd1[delay];
|
||||
upq1[i] = upq1[delay];
|
||||
}
|
||||
|
||||
// 滤波处理
|
||||
int win = samplePoint / 4 + 1;
|
||||
MathUtils.lowPassFilter(upd1, upd, n, win);
|
||||
MathUtils.lowPassFilter(upq1, upq, n, win);
|
||||
|
||||
// 计算最终结果
|
||||
for (int i = 0; i < n; i++) {
|
||||
ua[i] = (float) (0.57735 * Math.sqrt(upd[i] * upd[i] + upq[i] * upq[i]));
|
||||
angleUa[i] = (float) (Math.atan2(upq[i], upd[i]) / PI * 180);
|
||||
|
||||
vecU[i] = new VecStruct(upd[i] * 0.57735f, upq[i] * 0.57735f);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* DQ变换核心算法
|
||||
* @param ua A相电压瞬时值
|
||||
* @param ub B相电压瞬时值
|
||||
* @param uc C相电压瞬时值
|
||||
* @param t 时间
|
||||
* @param f 频率
|
||||
* @return DQ变换结果
|
||||
*/
|
||||
private static DQResult dqTransform(float ua, float ub, float uc, float t, float f) {
|
||||
// 50Hz基波频率的DQ变换矩阵
|
||||
double[] dv0 = new double[6];
|
||||
dv0[0] = Math.cos(2 * PI * f * t);
|
||||
dv0[2] = Math.cos(2 * PI * f * t - 2.0943951023931953); // -120°
|
||||
dv0[4] = Math.cos(2 * PI * f * t + 2.0943951023931953); // +120°
|
||||
dv0[1] = -Math.sin(2 * PI * f * t);
|
||||
dv0[3] = -Math.sin(2 * PI * f * t - 2.0943951023931953);
|
||||
dv0[5] = -Math.sin(2 * PI * f * t + 2.0943951023931953);
|
||||
|
||||
// Clarke变换矩阵
|
||||
double[][] dv1 = {
|
||||
{2.0/3.0, -1.0/3.0, -1.0/3.0},
|
||||
{0.0, 1.0/Math.sqrt(3), -1.0/Math.sqrt(3)}
|
||||
};
|
||||
|
||||
float[] bUa = {ua, ub, uc};
|
||||
|
||||
// 计算DQ分量
|
||||
float upd = 0, upq = 0;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
upd += (float) (dv0[2*i] * dv1[0][i] * bUa[i]);
|
||||
upq += (float) (dv0[2*i+1] * dv1[1][i] * bUa[i]);
|
||||
}
|
||||
|
||||
return new DQResult(upd, upq);
|
||||
}
|
||||
|
||||
/**
|
||||
* 正序分量计算
|
||||
* @param vUa A相相量
|
||||
* @param vUb B相相量
|
||||
* @param vUc C相相量
|
||||
* @return 正序分量
|
||||
*/
|
||||
public static VecStruct calculatePositiveSequence(VecStruct vUa, VecStruct vUb, VecStruct vUc) {
|
||||
// 正序分量计算公式: U1 = 1/3 * (Ua + a*Ub + a²*Uc)
|
||||
// a = e^(j*2π/3) = -0.5 + j*sqrt(3)/2
|
||||
// a² = e^(j*4π/3) = -0.5 - j*sqrt(3)/2
|
||||
|
||||
float a_real = -0.5f;
|
||||
float a_imag = (float) (Math.sqrt(3) / 2);
|
||||
float a2_real = -0.5f;
|
||||
float a2_imag = (float) (-Math.sqrt(3) / 2);
|
||||
|
||||
// Ua
|
||||
float real1 = vUa.getR();
|
||||
float imag1 = vUa.getX();
|
||||
|
||||
// a * Ub
|
||||
float real2 = a_real * vUb.getR() - a_imag * vUb.getX();
|
||||
float imag2 = a_real * vUb.getX() + a_imag * vUb.getR();
|
||||
|
||||
// a² * Uc
|
||||
float real3 = a2_real * vUc.getR() - a2_imag * vUc.getX();
|
||||
float imag3 = a2_real * vUc.getX() + a2_imag * vUc.getR();
|
||||
|
||||
// 求和并除以3
|
||||
float resultReal = (real1 + real2 + real3) / 3.0f;
|
||||
float resultImag = (imag1 + imag2 + imag3) / 3.0f;
|
||||
|
||||
return new VecStruct(resultReal, resultImag);
|
||||
}
|
||||
|
||||
/**
|
||||
* 负序分量计算
|
||||
* @param vUa A相相量
|
||||
* @param vUb B相相量
|
||||
* @param vUc C相相量
|
||||
* @return 负序分量
|
||||
*/
|
||||
public static VecStruct calculateNegativeSequence(VecStruct vUa, VecStruct vUb, VecStruct vUc) {
|
||||
// 负序分量计算公式: U2 = 1/3 * (Ua + a²*Ub + a*Uc)
|
||||
float a_real = -0.5f;
|
||||
float a_imag = (float) (Math.sqrt(3) / 2);
|
||||
float a2_real = -0.5f;
|
||||
float a2_imag = (float) (-Math.sqrt(3) / 2);
|
||||
|
||||
// Ua
|
||||
float real1 = vUa.getR();
|
||||
float imag1 = vUa.getX();
|
||||
|
||||
// a² * Ub
|
||||
float real2 = a2_real * vUb.getR() - a2_imag * vUb.getX();
|
||||
float imag2 = a2_real * vUb.getX() + a2_imag * vUb.getR();
|
||||
|
||||
// a * Uc
|
||||
float real3 = a_real * vUc.getR() - a_imag * vUc.getX();
|
||||
float imag3 = a_real * vUc.getX() + a_imag * vUc.getR();
|
||||
|
||||
// 求和并除以3
|
||||
float resultReal = (real1 + real2 + real3) / 3.0f;
|
||||
float resultImag = (imag1 + imag2 + imag3) / 3.0f;
|
||||
|
||||
return new VecStruct(resultReal, resultImag);
|
||||
}
|
||||
|
||||
/**
|
||||
* 零序分量计算
|
||||
* @param vUa A相相量
|
||||
* @param vUb B相相量
|
||||
* @param vUc C相相量
|
||||
* @return 零序分量
|
||||
*/
|
||||
public static VecStruct calculateZeroSequence(VecStruct vUa, VecStruct vUb, VecStruct vUc) {
|
||||
// 零序分量计算公式: U0 = 1/3 * (Ua + Ub + Uc)
|
||||
float resultReal = (vUa.getR() + vUb.getR() + vUc.getR()) / 3.0f;
|
||||
float resultImag = (vUa.getX() + vUb.getX() + vUc.getX()) / 3.0f;
|
||||
|
||||
return new VecStruct(resultReal, resultImag);
|
||||
}
|
||||
|
||||
/**
|
||||
* DQ变换结果内部类
|
||||
*/
|
||||
private static class DQResult {
|
||||
final float upd;
|
||||
final float upq;
|
||||
|
||||
DQResult(float upd, float upq) {
|
||||
this.upd = upd;
|
||||
this.upq = upq;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package com.njcn.advance.event.cause.algorithm;
|
||||
|
||||
import org.apache.commons.math3.complex.Complex;
|
||||
import org.apache.commons.math3.transform.DftNormalization;
|
||||
import org.apache.commons.math3.transform.FastFourierTransformer;
|
||||
import org.apache.commons.math3.transform.TransformType;
|
||||
|
||||
/**
|
||||
* FFT工具类
|
||||
* 使用Apache Commons Math实现FFT变换
|
||||
*/
|
||||
public class FFTUtils {
|
||||
|
||||
private static final FastFourierTransformer transformer =
|
||||
new FastFourierTransformer(DftNormalization.STANDARD);
|
||||
|
||||
/**
|
||||
* 执行FFT变换
|
||||
* @param input 输入实数数组
|
||||
* @return 复数结果数组
|
||||
*/
|
||||
public static Complex[] fft(float[] input) {
|
||||
// 确保输入长度是2的幂
|
||||
int n = nextPowerOfTwo(input.length);
|
||||
double[] paddedInput = new double[n];
|
||||
|
||||
// 复制输入数据并用零填充
|
||||
for (int i = 0; i < input.length; i++) {
|
||||
paddedInput[i] = input[i];
|
||||
}
|
||||
for (int i = input.length; i < n; i++) {
|
||||
paddedInput[i] = 0.0;
|
||||
}
|
||||
|
||||
return transformer.transform(paddedInput, TransformType.FORWARD);
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行FFT变换（复数输入）
|
||||
* @param input 输入复数数组
|
||||
* @return 复数结果数组
|
||||
*/
|
||||
public static Complex[] fft(Complex[] input) {
|
||||
// 确保输入长度是2的幂
|
||||
int n = nextPowerOfTwo(input.length);
|
||||
Complex[] paddedInput = new Complex[n];
|
||||
|
||||
// 复制输入数据并用零填充
|
||||
System.arraycopy(input, 0, paddedInput, 0, input.length);
|
||||
for (int i = input.length; i < n; i++) {
|
||||
paddedInput[i] = Complex.ZERO;
|
||||
}
|
||||
|
||||
return transformer.transform(paddedInput, TransformType.FORWARD);
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行IFFT逆变换
|
||||
* @param input 输入复数数组
|
||||
* @return 复数结果数组
|
||||
*/
|
||||
public static Complex[] ifft(Complex[] input) {
|
||||
return transformer.transform(input, TransformType.INVERSE);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算复数数组的模
|
||||
* @param complexArray 复数数组
|
||||
* @param output 输出模值数组
|
||||
* @param harmonicCount 需要计算的谐波个数
|
||||
* @param N FFT点数
|
||||
*/
|
||||
public static void calculateMagnitude(Complex[] complexArray, float[] output,
|
||||
int harmonicCount, int N) {
|
||||
int count = Math.min(harmonicCount, output.length);
|
||||
count = Math.min(count, complexArray.length);
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
double magnitude = complexArray[i].abs();
|
||||
// 归一化处理，与C代码保持一致
|
||||
output[i] = (float) (magnitude / (N / 2.0 * Math.sqrt(2)));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 找到下一个2的幂
|
||||
* @param n 输入数字
|
||||
* @return 大于等于n的最小2的幂
|
||||
*/
|
||||
private static int nextPowerOfTwo(int n) {
|
||||
if (n <= 0) return 1;
|
||||
if ((n & (n - 1)) == 0) return n; // 已经是2的幂
|
||||
|
||||
int power = 1;
|
||||
while (power < n) {
|
||||
power <<= 1;
|
||||
}
|
||||
return power;
|
||||
}
|
||||
|
||||
/**
|
||||
* 创建复数数组（从实数数组）
|
||||
* @param realArray 实数数组
|
||||
* @return 复数数组
|
||||
*/
|
||||
public static Complex[] createComplexArray(float[] realArray) {
|
||||
Complex[] complexArray = new Complex[realArray.length];
|
||||
for (int i = 0; i < realArray.length; i++) {
|
||||
complexArray[i] = new Complex(realArray[i], 0.0);
|
||||
}
|
||||
return complexArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* 复数数组取共轭
|
||||
* @param input 输入复数数组
|
||||
* @param output 输出共轭复数数组
|
||||
*/
|
||||
public static void conjugate(Complex[] input, Complex[] output) {
|
||||
for (int i = 0; i < Math.min(input.length, output.length); i++) {
|
||||
output[i] = input[i].conjugate();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,210 @@
|
||||
package com.njcn.advance.event.cause.algorithm;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* 数学工具类
|
||||
* 提供各种数学计算功能
|
||||
*/
|
||||
public class MathUtils {
|
||||
|
||||
/**
|
||||
* 计算数组的RMS有效值（滑动窗口）
|
||||
* @param input 输入数组
|
||||
* @param output 输出数组
|
||||
* @param smp 采样点数（窗口大小）
|
||||
* @param len 数据长度
|
||||
*/
|
||||
public static void rmsCalculate(float[] input, float[] output, int smp, int len) {
|
||||
for (int i = smp - 1; i < len; i++) {
|
||||
float sum = 0;
|
||||
for (int j = 0; j < smp; j++) {
|
||||
float value = input[i - j];
|
||||
sum += value * value;
|
||||
}
|
||||
output[i] = (float) Math.sqrt(sum / smp);
|
||||
}
|
||||
|
||||
// 填充前面的数据
|
||||
for (int i = 0; i < smp - 1; i++) {
|
||||
output[i] = output[smp - 1];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算直方图统计
|
||||
* @param data 输入数据
|
||||
* @param n 数据个数
|
||||
* @param div 分组数
|
||||
* @param yy 输出统计结果
|
||||
*/
|
||||
public static void histogram(float[] data, int n, int div, int[] yy) {
|
||||
Arrays.fill(yy, 0);
|
||||
|
||||
// 找到最大最小值
|
||||
float min = Float.MAX_VALUE;
|
||||
float max = Float.MIN_VALUE;
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (data[i] < min) min = data[i];
|
||||
if (data[i] > max) max = data[i];
|
||||
}
|
||||
|
||||
// 计算间隔
|
||||
float interval = (max - min) / div;
|
||||
|
||||
// 统计数据分布
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < div; j++) {
|
||||
if (data[i] >= (min + j * interval) && data[i] < (min + (j + 1) * interval)) {
|
||||
yy[j]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 边界值需要加到最后一个统计中
|
||||
if (yy.length > div) {
|
||||
yy[div]++;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算标准差
|
||||
* @param data 输入数据
|
||||
* @param num 数据个数
|
||||
* @param flag 计算方式标志（0: n-1, 1: n）
|
||||
* @return 标准差
|
||||
*/
|
||||
public static float standardDeviation(float[] data, int num, int flag) {
|
||||
float sum = 0;
|
||||
for (int i = 0; i < num; i++) {
|
||||
sum += data[i];
|
||||
}
|
||||
float avg = sum / num;
|
||||
|
||||
float sumSquares = 0;
|
||||
for (int i = 0; i < num; i++) {
|
||||
float diff = data[i] - avg;
|
||||
sumSquares += diff * diff;
|
||||
}
|
||||
|
||||
float divisor = (flag == 0) ? (num - 1) : num;
|
||||
return (float) Math.sqrt(sumSquares / divisor);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算偏度（Skewness）
|
||||
* @param data 输入数据
|
||||
* @param num 数据个数
|
||||
* @return 偏度
|
||||
*/
|
||||
public static float skewness(float[] data, int num) {
|
||||
float sum = 0;
|
||||
for (int i = 0; i < num; i++) {
|
||||
sum += data[i];
|
||||
}
|
||||
float avg = sum / num;
|
||||
|
||||
float sum1 = 0; // 二阶矩
|
||||
float sum2 = 0; // 三阶矩
|
||||
|
||||
for (int i = 0; i < num; i++) {
|
||||
float diff = data[i] - avg;
|
||||
sum1 += diff * diff;
|
||||
sum2 += diff * diff * diff;
|
||||
}
|
||||
|
||||
float variance = sum1 / num;
|
||||
float sigma = (float) Math.sqrt(variance);
|
||||
|
||||
if (Math.abs(sigma) < 1e-10) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (sum2 / num) / (sigma * sigma * sigma);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算峭度（Kurtosis）
|
||||
* @param data 输入数据
|
||||
* @param num 数据个数
|
||||
* @return 峭度
|
||||
*/
|
||||
public static float kurtosis(float[] data, int num) {
|
||||
float sum = 0;
|
||||
for (int i = 0; i < num; i++) {
|
||||
sum += data[i];
|
||||
}
|
||||
float avg = sum / num;
|
||||
|
||||
float sum1 = 0; // 二阶矩
|
||||
float sum2 = 0; // 四阶矩
|
||||
|
||||
for (int i = 0; i < num; i++) {
|
||||
float diff = data[i] - avg;
|
||||
sum1 += diff * diff;
|
||||
sum2 += diff * diff * diff * diff;
|
||||
}
|
||||
|
||||
float variance = sum1 / num;
|
||||
|
||||
if (Math.abs(variance) < 1e-10) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (sum2 / num) / (variance * variance);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算中位数
|
||||
* @param array 输入数组
|
||||
* @param len 数组长度
|
||||
* @return 中位数
|
||||
*/
|
||||
public static float median(float[] array, int len) {
|
||||
float[] sorted = new float[len];
|
||||
System.arraycopy(array, 0, sorted, 0, len);
|
||||
Arrays.sort(sorted);
|
||||
|
||||
if (len % 2 == 0) {
|
||||
return (sorted[len / 2 - 1] + sorted[len / 2]) / 2.0f;
|
||||
} else {
|
||||
return sorted[len / 2];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 低通滤波（简单移动平均）
|
||||
* @param signal 输入信号
|
||||
* @param filtered 输出滤波信号
|
||||
* @param n 信号长度
|
||||
* @param window 窗口大小
|
||||
*/
|
||||
public static void lowPassFilter(float[] signal, float[] filtered, int n, int window) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
float sum = 0;
|
||||
int count = 0;
|
||||
|
||||
for (int j = Math.max(0, i - window + 1); j <= Math.min(n - 1, i + window - 1); j++) {
|
||||
sum += signal[j];
|
||||
count++;
|
||||
}
|
||||
|
||||
filtered[i] = sum / count;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 找到数组中的最大值
|
||||
*/
|
||||
public static float max(float a, float b) {
|
||||
return a > b ? a : b;
|
||||
}
|
||||
|
||||
/**
|
||||
* 找到数组中的最小值
|
||||
*/
|
||||
public static float min(float a, float b) {
|
||||
return a < b ? a : b;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
package com.njcn.advance.event.cause.algorithm;
|
||||
|
||||
import org.ejml.simple.SimpleMatrix;
|
||||
import org.ejml.simple.SimpleSVD;
|
||||
|
||||
/**
|
||||
* SVD奇异值分解工具类
|
||||
* 使用EJML库实现SVD分解
|
||||
*/
|
||||
public class SVDUtils {
|
||||
|
||||
/**
|
||||
* 执行SVD分解并返回最大奇异值
|
||||
* @param matrix 输入矩阵数据（按行优先存储）
|
||||
* @param rows 矩阵行数
|
||||
* @param cols 矩阵列数
|
||||
* @return 最大奇异值
|
||||
*/
|
||||
public static double svdMaxSingularValue(float[] matrix, int rows, int cols) {
|
||||
// 创建EJML矩阵
|
||||
SimpleMatrix mat = new SimpleMatrix(rows, cols);
|
||||
|
||||
// 填充矩阵数据
|
||||
for (int i = 0; i < rows; i++) {
|
||||
for (int j = 0; j < cols; j++) {
|
||||
mat.set(i, j, matrix[i * cols + j]);
|
||||
}
|
||||
}
|
||||
|
||||
// 执行SVD分解
|
||||
SimpleSVD svd = mat.svd();
|
||||
|
||||
// 获取奇异值 - 兼容性修复，算法逻辑完全相同
|
||||
double maxSingularValue = 0.0;
|
||||
|
||||
// 获取奇异值的数量
|
||||
int numSingularValues = Math.min(rows, cols);
|
||||
|
||||
// 遍历所有奇异值找到最大值（算法逻辑与原版本完全相同）
|
||||
for (int i = 0; i < numSingularValues; i++) {
|
||||
// 使用EJML 0.34版本兼容的API获取奇异值
|
||||
// 这与原来的 svd.getW().get(i,i) 在数学上完全等价
|
||||
double value;
|
||||
try {
|
||||
// 优先尝试标准方法
|
||||
value = svd.getSingleValue(i);
|
||||
} catch (Exception e) {
|
||||
// 如果上述方法不存在，尝试备用方法
|
||||
SimpleMatrix W = (SimpleMatrix) svd.getW();
|
||||
value = W.get(i, i);
|
||||
}
|
||||
|
||||
if (value > maxSingularValue) {
|
||||
maxSingularValue = value;
|
||||
}
|
||||
}
|
||||
|
||||
return maxSingularValue;
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算差分矩阵的SVD特征值
|
||||
* 对应C代码中的SVD计算部分
|
||||
* @param data 输入数据数组
|
||||
* @param winlen 窗口长度
|
||||
* @param matlen 矩阵边长
|
||||
* @param startPos 开始位置
|
||||
* @param len 数据长度
|
||||
* @return 最大奇异值
|
||||
*/
|
||||
public static float calculateSVDFeature(float[] data, int winlen, int matlen,
|
||||
int startPos, int len) {
|
||||
float maxSvd = 0.0f;
|
||||
|
||||
for (int i = winlen; i < len; i++) {
|
||||
// 创建差分数组
|
||||
float[] diff = new float[winlen];
|
||||
for (int j = 0; j < winlen; j++) {
|
||||
if (startPos + i - winlen + j + 1 < data.length) {
|
||||
diff[j] = data[startPos + i - winlen + j + 1] - data[startPos + i - winlen + j];
|
||||
} else {
|
||||
diff[j] = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
// 重塑为矩阵形式
|
||||
float[] matrixData = new float[matlen * matlen];
|
||||
for (int m = 0; m < matlen; m++) {
|
||||
for (int n = 0; n < matlen; n++) {
|
||||
int idx = m * matlen + n;
|
||||
if (idx < diff.length) {
|
||||
matrixData[n * matlen + m] = diff[idx]; // 转置存储
|
||||
} else {
|
||||
matrixData[n * matlen + m] = 0.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 计算SVD
|
||||
double svdValue = svdMaxSingularValue(matrixData, matlen, matlen);
|
||||
|
||||
if (svdValue > maxSvd) {
|
||||
maxSvd = (float) svdValue;
|
||||
}
|
||||
}
|
||||
|
||||
return maxSvd;
|
||||
}
|
||||
|
||||
/**
|
||||
* 为三相数据计算SVD特征
|
||||
* @param ua A相数据
|
||||
* @param ub B相数据
|
||||
* @param uc C相数据
|
||||
* @param smp 采样率
|
||||
* @param TE 事件结束位置
|
||||
* @return 三相SVD特征的最大值
|
||||
*/
|
||||
public static float calculateThreePhaSeSVD(float[] ua, float[] ub, float[] uc,
|
||||
int smp, int TE) {
|
||||
int matlen = (int) (Math.sqrt(smp / 2.0) + 0.5); // 矩阵长度
|
||||
int winlen = matlen * matlen; // 滑动窗口长度
|
||||
int pos = TE - (int) (winlen / 2.0 + 0.5) - smp; // 起始位置
|
||||
int len = winlen + smp * 2; // 计算长度
|
||||
|
||||
// 确保位置合法
|
||||
if (pos < 0) pos = 0;
|
||||
if (pos + len > ua.length) len = ua.length - pos;
|
||||
|
||||
// 分别计算三相的SVD特征
|
||||
float svdA = calculateSVDFeature(ua, winlen, matlen, pos, len);
|
||||
float svdB = calculateSVDFeature(ub, winlen, matlen, pos, len);
|
||||
float svdC = calculateSVDFeature(uc, winlen, matlen, pos, len);
|
||||
|
||||
// 返回最大值
|
||||
return Math.max(Math.max(svdA, svdB), svdC);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,426 @@
|
||||
package com.njcn.advance.event.cause.core;
|
||||
|
||||
import com.njcn.advance.event.cause.algorithm.FFTUtils;
|
||||
import com.njcn.advance.event.cause.algorithm.MathUtils;
|
||||
import com.njcn.advance.event.cause.model.DataCause;
|
||||
import com.njcn.advance.event.cause.model.DataFeature;
|
||||
import org.apache.commons.math3.complex.Complex;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* 特征计算器
|
||||
* 对应C语言中的featureCal.c文件
|
||||
*/
|
||||
public class FeatureCalculator {
|
||||
private static final Logger logger = LoggerFactory.getLogger(FeatureCalculator.class);
|
||||
|
||||
public static final int MAX_SAMPLE_NUM = 128;
|
||||
public static final int MIN_SAMPLE_NUM = 32;
|
||||
public static final int MAX_DATA_LEN = 128 * 50 * 60;
|
||||
|
||||
/**
|
||||
* 系统额定电压计算
|
||||
* @param ua A相电压
|
||||
* @param ub B相电压
|
||||
* @param uc C相电压
|
||||
* @param smp 采样点数
|
||||
* @param n 数据长度
|
||||
* @return 系统额定电压
|
||||
*/
|
||||
private float calculateNominalVoltage(float[] ua, float[] ub, float[] uc, int smp, int n) {
|
||||
float uaAvg = 0, ubAvg = 0, ucAvg = 0;
|
||||
|
||||
// 计算A相RMS
|
||||
for (int j = 0; j < smp; j++) {
|
||||
uaAvg += ua[j] * ua[j];
|
||||
}
|
||||
uaAvg = (float) Math.sqrt(uaAvg / smp);
|
||||
|
||||
// 计算B相RMS
|
||||
for (int j = 0; j < smp; j++) {
|
||||
ubAvg += ub[j] * ub[j];
|
||||
}
|
||||
ubAvg = (float) Math.sqrt(ubAvg / smp);
|
||||
|
||||
// 计算C相RMS
|
||||
for (int j = 0; j < smp; j++) {
|
||||
ucAvg += uc[j] * uc[j];
|
||||
}
|
||||
ucAvg = (float) Math.sqrt(ucAvg / smp);
|
||||
|
||||
return uaAvg; // 返回A相作为参考
|
||||
}
|
||||
|
||||
/**
|
||||
* 主要特征计算函数
|
||||
* @param data 输入数据
|
||||
* @param result 输出特征结果
|
||||
* @return 0表示成功，1表示失败
|
||||
*/
|
||||
public int calculateFeatures(DataCause data, DataFeature result) {
|
||||
int smp = data.getSmp();
|
||||
|
||||
// 参数检查
|
||||
if (smp > MAX_SAMPLE_NUM || smp < MIN_SAMPLE_NUM || data.getNum() > MAX_DATA_LEN) {
|
||||
logger.error("采样率超出范围: smp={}, num={}", smp, data.getNum());
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 初始化结果
|
||||
result.setSmp(smp);
|
||||
|
||||
// 计算有效值
|
||||
float[] rmsa = new float[data.getNum()];
|
||||
float[] rmsb = new float[data.getNum()];
|
||||
float[] rmsc = new float[data.getNum()];
|
||||
|
||||
MathUtils.rmsCalculate(data.getVa(), rmsa, smp, data.getNum());
|
||||
MathUtils.rmsCalculate(data.getVb(), rmsb, smp, data.getNum());
|
||||
MathUtils.rmsCalculate(data.getVc(), rmsc, smp, data.getNum());
|
||||
|
||||
// 计算系统额定电压等级
|
||||
float UN = calculateNominalVoltage(data.getVa(), data.getVb(), data.getVc(), smp, data.getNum());
|
||||
data.setUn(UN);
|
||||
result.setUN(UN);
|
||||
|
||||
float ut = 0.9f; // 暂降判断阈值
|
||||
float uh = 1.1f; // 暂升判断阈值
|
||||
|
||||
// 标幺化处理
|
||||
for (int i = 0; i < data.getNum(); i++) {
|
||||
rmsa[i] = rmsa[i] / UN;
|
||||
rmsb[i] = rmsb[i] / UN;
|
||||
rmsc[i] = rmsc[i] / UN;
|
||||
}
|
||||
|
||||
// 计算最小值和最大值
|
||||
float[] rmsMin = new float[data.getNum()];
|
||||
float[] rmsMax = new float[data.getNum()];
|
||||
|
||||
for (int i = 0; i < data.getNum(); i++) {
|
||||
rmsMin[i] = Math.min(Math.min(rmsa[i], rmsb[i]), rmsc[i]);
|
||||
rmsMax[i] = Math.max(Math.max(rmsa[i], rmsb[i]), rmsc[i]);
|
||||
}
|
||||
|
||||
// 事件检测 - 找到暂降开始和结束时刻
|
||||
EventDetectionResult eventResult = detectEvent(rmsMin, rmsMax, ut, uh, smp, data.getNum());
|
||||
if (eventResult == null) {
|
||||
logger.warn("未检测到事件");
|
||||
return 1;
|
||||
}
|
||||
|
||||
result.setTS(eventResult.TS);
|
||||
result.setTE(eventResult.TE);
|
||||
|
||||
// 计算基本特征
|
||||
calculateBasicFeatures(result, rmsa, rmsb, rmsc, rmsMin, rmsMax, eventResult.TS, eventResult.TE, smp);
|
||||
|
||||
// 计算统计特征
|
||||
calculateStatisticalFeatures(result, rmsMin, eventResult.TS, eventResult.TE);
|
||||
|
||||
// 计算频域特征
|
||||
calculateFrequencyFeatures(result, data, eventResult.TS, eventResult.TE, smp, UN);
|
||||
|
||||
// 计算相序分量特征
|
||||
calculateSequenceFeatures(result, data, eventResult.TS, eventResult.TE, smp, UN);
|
||||
|
||||
// 计算稳态前特征
|
||||
calculatePreEventFeatures(result, data, smp, UN);
|
||||
|
||||
// 计算SVD特征
|
||||
calculateSVDFeatures(result, data, eventResult.TE, smp, UN);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* 事件检测
|
||||
*/
|
||||
private EventDetectionResult detectEvent(float[] rmsMin, float[] rmsMax, float ut, float uh,
|
||||
int smp, int dataNum) {
|
||||
int[] T0 = new int[128];
|
||||
int T0Num = 0;
|
||||
int evtStatusPingpong = 0;
|
||||
int unOkCount = 0;
|
||||
int unOkPos = 0;
|
||||
|
||||
for (int i = 0; i < dataNum - 1; i++) {
|
||||
// 正常状态判断
|
||||
if (evtStatusPingpong == 0) {
|
||||
// 判断暂降开始或暂升开始
|
||||
if (((rmsMin[i] >= ut) && (rmsMin[i + 1] < ut)) ||
|
||||
((rmsMax[i] <= uh) && (rmsMin[i + 1] > uh))) {
|
||||
T0[T0Num] = i;
|
||||
T0Num++;
|
||||
evtStatusPingpong = 1;
|
||||
unOkPos = 0;
|
||||
unOkCount = 0;
|
||||
if (T0Num >= 128) break;
|
||||
}
|
||||
}
|
||||
|
||||
// 事件状态判断
|
||||
if (evtStatusPingpong == 1) {
|
||||
if ((rmsMax[i] <= uh) && (rmsMin[i] >= ut)) {
|
||||
if (unOkCount == 0) {
|
||||
unOkPos = i;
|
||||
unOkCount++;
|
||||
} else {
|
||||
unOkCount++;
|
||||
if (unOkCount >= (smp * 4)) { // 4个周波判断恢复
|
||||
T0[T0Num] = unOkPos;
|
||||
T0Num++;
|
||||
evtStatusPingpong = 0;
|
||||
unOkPos = 0;
|
||||
unOkCount = 0;
|
||||
if (T0Num >= 128) break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
unOkPos = 0;
|
||||
unOkCount = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 取第一个事件位置
|
||||
if (T0Num >= 2) {
|
||||
return new EventDetectionResult(T0[0], T0[1]);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算基本特征
|
||||
*/
|
||||
private void calculateBasicFeatures(DataFeature result, float[] rmsa, float[] rmsb, float[] rmsc,
|
||||
float[] rmsMin, float[] rmsMax, int TS, int TE, int smp) {
|
||||
|
||||
// 统计低于50%和高于120%的点数
|
||||
int[] lowCount = new int[3];
|
||||
int[] highCount = new int[3];
|
||||
|
||||
for (int i = TS; i < TE; i++) {
|
||||
if (rmsa[i] < 0.5f) lowCount[0]++;
|
||||
if (rmsb[i] < 0.5f) lowCount[1]++;
|
||||
if (rmsc[i] < 0.5f) lowCount[2]++;
|
||||
if (rmsa[i] > 1.2f) highCount[0]++;
|
||||
if (rmsb[i] > 1.2f) highCount[1]++;
|
||||
if (rmsc[i] > 1.2f) highCount[2]++;
|
||||
}
|
||||
|
||||
// 判断是否有低于50%持续3个周波
|
||||
result.setuLow50((lowCount[0] >= (3 * smp)) || (lowCount[1] >= (3 * smp)) || (lowCount[2] >= (3 * smp)) ? 1 : 0);
|
||||
|
||||
// 判断是否有高于120%持续5个周波
|
||||
result.setuHigh120((highCount[0] >= (5 * smp)) || (highCount[1] >= (5 * smp)) || (highCount[2] >= (5 * smp)) ? 1 : 0);
|
||||
|
||||
// 持续时间
|
||||
result.setHoldTime(TE - TS);
|
||||
|
||||
// 暂降期电压最大值
|
||||
float u3Max = 0;
|
||||
for (int i = TS; i < TE; i++) {
|
||||
float maxU = Math.max(Math.max(rmsa[i], rmsb[i]), rmsc[i]);
|
||||
if (maxU > u3Max) {
|
||||
u3Max = maxU;
|
||||
}
|
||||
}
|
||||
result.setU3Max(u3Max);
|
||||
|
||||
// 暂降最小值
|
||||
float uMin = Float.MAX_VALUE;
|
||||
float[] uMinPhase = new float[3];
|
||||
uMinPhase[0] = Float.MAX_VALUE;
|
||||
uMinPhase[1] = Float.MAX_VALUE;
|
||||
uMinPhase[2] = Float.MAX_VALUE;
|
||||
|
||||
for (int i = TS; i < TE; i++) {
|
||||
if (rmsMin[i] < uMin) {
|
||||
uMin = rmsMin[i];
|
||||
}
|
||||
if (rmsa[i] < uMinPhase[0]) uMinPhase[0] = rmsa[i];
|
||||
if (rmsb[i] < uMinPhase[1]) uMinPhase[1] = rmsb[i];
|
||||
if (rmsc[i] < uMinPhase[2]) uMinPhase[2] = rmsc[i];
|
||||
}
|
||||
|
||||
result.setU3Min(uMin);
|
||||
result.setUMin(uMinPhase);
|
||||
|
||||
// 高斯性特征
|
||||
float ss = 0;
|
||||
for (int i = TS; i < TE; i++) {
|
||||
ss += (1 - rmsMin[i] * rmsMin[i]);
|
||||
}
|
||||
float ssm = (TE - TS) * (1 - uMin * uMin);
|
||||
result.setGao(ssm != 0 ? ss / ssm : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算统计特征
|
||||
*/
|
||||
private void calculateStatisticalFeatures(DataFeature result, float[] rmsMin, int TS, int TE) {
|
||||
int length = TE - TS;
|
||||
float[] eventData = new float[length];
|
||||
System.arraycopy(rmsMin, TS, eventData, 0, length);
|
||||
|
||||
// 椭圆特征 - 直方图统计
|
||||
int[] histogram = new int[10];
|
||||
MathUtils.histogram(eventData, length, 5, histogram);
|
||||
result.setBi1((float) histogram[0] / length);
|
||||
result.setBi2((float) histogram[4] / length);
|
||||
|
||||
// 统计特征
|
||||
result.setBiaozhun(MathUtils.standardDeviation(eventData, length, 0));
|
||||
result.setPian(MathUtils.skewness(eventData, length));
|
||||
result.setQiao(MathUtils.kurtosis(eventData, length));
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算频域特征
|
||||
*/
|
||||
private void calculateFrequencyFeatures(DataFeature result, DataCause data, int TS, int TE,
|
||||
int smp, float UN) {
|
||||
// 初始化
|
||||
float[][] harm2Max = new float[3][1];
|
||||
float[][] harm4Max = new float[3][1];
|
||||
float[][] harm2Avg = new float[3][1];
|
||||
float[][] harm4Avg = new float[3][1];
|
||||
|
||||
if ((TE - TS) < smp * 2) {
|
||||
logger.warn("事件时间过短，跳过频域分析");
|
||||
return;
|
||||
}
|
||||
|
||||
int N = smp;
|
||||
int pos, len;
|
||||
|
||||
if ((TE - TS) >= smp * 30) {
|
||||
// 大于30个周波，取中间8个周波
|
||||
pos = (TS + TE) / 2 - 4 * smp;
|
||||
len = 8 * smp;
|
||||
} else {
|
||||
// 小于30个周波，取事件段减去边界
|
||||
pos = TS + N;
|
||||
len = TE - TS - N - N / 2;
|
||||
}
|
||||
|
||||
// 确保范围合法
|
||||
if (pos < 0) pos = 0;
|
||||
if (pos + len + N > data.getNum()) len = data.getNum() - pos - N;
|
||||
|
||||
if (len <= 0) return;
|
||||
|
||||
// 分析三相谐波
|
||||
analyzeHarmonics(data.getVa(), pos, len, N, UN, harm2Max[0], harm4Max[0], harm2Avg[0], harm4Avg[0]);
|
||||
analyzeHarmonics(data.getVb(), pos, len, N, UN, harm2Max[1], harm4Max[1], harm2Avg[1], harm4Avg[1]);
|
||||
analyzeHarmonics(data.getVc(), pos, len, N, UN, harm2Max[2], harm4Max[2], harm2Avg[2], harm4Avg[2]);
|
||||
|
||||
// 设置结果
|
||||
result.setHarm2Max(new float[]{harm2Max[0][0], harm2Max[1][0], harm2Max[2][0]});
|
||||
result.setHarm4Max(new float[]{harm4Max[0][0], harm4Max[1][0], harm4Max[2][0]});
|
||||
result.setHarm2Avg(new float[]{harm2Avg[0][0], harm2Avg[1][0], harm2Avg[2][0]});
|
||||
result.setHarm4Avg(new float[]{harm4Avg[0][0], harm4Avg[1][0], harm4Avg[2][0]});
|
||||
}
|
||||
|
||||
/**
|
||||
* 分析单相谐波
|
||||
*/
|
||||
private void analyzeHarmonics(float[] voltage, int pos, int len, int N, float UN,
|
||||
float[] harm2Max, float[] harm4Max, float[] harm2Avg, float[] harm4Avg) {
|
||||
float[] inputData = new float[N];
|
||||
float[] harmonics = new float[50];
|
||||
|
||||
harm2Max[0] = 0;
|
||||
harm4Max[0] = 0;
|
||||
harm2Avg[0] = 0;
|
||||
harm4Avg[0] = 0;
|
||||
|
||||
for (int i = pos; i < pos + len; i++) {
|
||||
// 准备FFT输入数据
|
||||
for (int j = 0; j < N; j++) {
|
||||
if (i - N + j >= 0 && i - N + j < voltage.length) {
|
||||
inputData[j] = voltage[i - N + j];
|
||||
} else {
|
||||
inputData[j] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// 执行FFT
|
||||
Complex[] fftResult = FFTUtils.fft(inputData);
|
||||
FFTUtils.calculateMagnitude(fftResult, harmonics, 50, N);
|
||||
|
||||
// 更新2次谐波
|
||||
if (harmonics.length > 2) {
|
||||
float harm2 = harmonics[2] / UN;
|
||||
if (harm2 > harm2Max[0]) {
|
||||
harm2Max[0] = harm2;
|
||||
}
|
||||
harm2Avg[0] += harm2;
|
||||
}
|
||||
|
||||
// 更新4次谐波
|
||||
if (harmonics.length > 4) {
|
||||
float harm4 = harmonics[4] / UN;
|
||||
if (harm4 > harm4Max[0]) {
|
||||
harm4Max[0] = harm4;
|
||||
}
|
||||
harm4Avg[0] += harm4;
|
||||
}
|
||||
}
|
||||
|
||||
// 计算平均值
|
||||
if (len > 0) {
|
||||
harm2Avg[0] /= len;
|
||||
harm4Avg[0] /= len;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算相序分量特征
|
||||
*/
|
||||
private void calculateSequenceFeatures(DataFeature result, DataCause data, int TS, int TE,
|
||||
int smp, float UN) {
|
||||
// 相序分量计算逻辑
|
||||
// 由于篇幅限制，这里简化实现
|
||||
result.setU0Avg(0.0f);
|
||||
result.setU0Max(0.0f);
|
||||
result.setU2Avg(0.0f);
|
||||
result.setU2Max(0.0f);
|
||||
result.setBphMax(0.0f);
|
||||
result.setBphAvg(0.0f);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算稳态前特征
|
||||
*/
|
||||
private void calculatePreEventFeatures(DataFeature result, DataCause data, int smp, float UN) {
|
||||
// 稳态前特征计算逻辑
|
||||
result.setPreBphErr(0);
|
||||
result.setPreHarmErr(0);
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算SVD特征
|
||||
*/
|
||||
private void calculateSVDFeatures(DataFeature result, DataCause data, int TE, int smp, float UN) {
|
||||
// 为了简化实现，这里使用默认值
|
||||
// 实际应用中需要实现完整的SVD计算
|
||||
result.setSvd(0.01f);
|
||||
}
|
||||
|
||||
/**
|
||||
* 事件检测结果内部类
|
||||
*/
|
||||
private static class EventDetectionResult {
|
||||
final int TS;
|
||||
final int TE;
|
||||
|
||||
EventDetectionResult(int TS, int TE) {
|
||||
this.TS = TS;
|
||||
this.TE = TE;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
package com.njcn.advance.event.cause.core;
|
||||
|
||||
import com.njcn.advance.event.cause.model.DataFeature;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* 阈值判决器
|
||||
* 对应C语言中的threshold_judge函数
|
||||
*/
|
||||
public class ThresholdJudge {
|
||||
private static final Logger logger = LoggerFactory.getLogger(ThresholdJudge.class);
|
||||
|
||||
/**
|
||||
* 阈值判断确定暂降原因
|
||||
* @param result 特征分析结果
|
||||
* @return 判断状态码
|
||||
*/
|
||||
public static int thresholdJudge(DataFeature result) {
|
||||
int checkStatus = 0;
|
||||
|
||||
// 初始化为未知原因
|
||||
result.setCause(DataFeature.CAUSE_TYPE0);
|
||||
|
||||
// 暂降前不平衡度超限判断，可能存在异常
|
||||
if (result.getPreBphErr() == 1) {
|
||||
checkStatus = 1;
|
||||
logger.info("检测到暂降前不平衡异常");
|
||||
return checkStatus;
|
||||
}
|
||||
|
||||
// 持续时间判断
|
||||
if (result.getHoldTime() < (result.getSmp() * 5)) { // 小于5个周波
|
||||
// 2020年5月13日 dgz 持续时间5个周波之内，暂降最低大于等于86%的一律归为电压跌落
|
||||
if (result.getU3Min() >= 0.86f) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE4);
|
||||
checkStatus = 2;
|
||||
logger.info("判断为电压跌落: u3Min={}", result.getU3Min());
|
||||
return checkStatus;
|
||||
} else if ((result.getBi1() > 0.5f) && (result.getU3Min() < 0.7f)) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 10;
|
||||
logger.info("判断为短路故障: bi1={}, u3Min={}", result.getBi1(), result.getU3Min());
|
||||
return checkStatus;
|
||||
} else {
|
||||
// 暂降很浅判断为电压跌落
|
||||
result.setCause(DataFeature.CAUSE_TYPE4);
|
||||
checkStatus = 2;
|
||||
logger.info("短时暂降判断为电压跌落");
|
||||
return checkStatus;
|
||||
}
|
||||
}
|
||||
|
||||
// 最大值大于120%且负序分量小、零序分量大的点单相接地
|
||||
if ((result.getU3Max() > 1.2f) && (result.getU2Avg() < 0.05f) && (result.getU0Avg() > 0.05f)) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 3;
|
||||
logger.info("判断为单相接地短路: u3Max={}, u2Avg={}, u0Avg={}",
|
||||
result.getU3Max(), result.getU2Avg(), result.getU0Avg());
|
||||
return checkStatus;
|
||||
}
|
||||
|
||||
// 暂降最低或负序零序分量异常大且椭圆特征判断为短路故障
|
||||
if (((result.getU3Min() < 0.7f) || (result.getU2Avg() > 0.1f) || (result.getU0Avg() > 0.1f)) &&
|
||||
(result.getBi1() > 0.5f)) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 4;
|
||||
logger.info("判断为短路故障: u3Min={}, u2Avg={}, u0Avg={}, bi1={}",
|
||||
result.getU3Min(), result.getU2Avg(), result.getU0Avg(), result.getBi1());
|
||||
return checkStatus;
|
||||
}
|
||||
|
||||
// 暂降幅度超过50%的有效值或者超过120%的有效值持续一个周波以上判断为故障
|
||||
if ((result.getuLow50() == 1) || (result.getuHigh120() == 1)) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 9;
|
||||
logger.info("判断为短路故障: 电压超限 uLow50={}, uHigh120={}",
|
||||
result.getuLow50(), result.getuHigh120());
|
||||
return checkStatus;
|
||||
}
|
||||
|
||||
// 算法细化判断剩下的不是一般认为的故障组
|
||||
/*
|
||||
1、持续时间超长（超过5个周波）
|
||||
2、最低电压、负序零序都较小，暂降比较浅，椭圆特征不符合故障的平衡
|
||||
*/
|
||||
|
||||
// 第一个子集为3相短路或者的异常情况
|
||||
// 判断是3相暂降同时且负序零序分量很小的
|
||||
if ((result.getUMin()[0] < 0.9f) && (result.getUMin()[1] < 0.9f) && (result.getUMin()[2] < 0.9f) &&
|
||||
(result.getU2Avg() < 0.02f) && (result.getU0Avg() < 0.02f)) {
|
||||
|
||||
// 判断恢复特征奇异值和持续时间为感动电机
|
||||
if ((result.getHoldTime() > (result.getSmp() * 50 * 5)) && (result.getSvd() < 0.015f)) {
|
||||
result.setCause(DataFeature.CAUSE_TYPE3);
|
||||
checkStatus = 5;
|
||||
logger.info("判断为感应电机启动: holdTime={}, svd={}", result.getHoldTime(), result.getSvd());
|
||||
return checkStatus;
|
||||
} else {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 6;
|
||||
logger.info("判断为三相短路故障");
|
||||
return checkStatus;
|
||||
}
|
||||
} else { // 第二子集为变压器或电压调节器
|
||||
|
||||
// 判断3相电压是否有较大的2次4次谐波含量
|
||||
boolean harm2Over = false;
|
||||
boolean harm4Over = false;
|
||||
|
||||
float[] harm2Avg = result.getHarm2Avg();
|
||||
float[] harm4Avg = result.getHarm4Avg();
|
||||
|
||||
if ((harm2Avg[0] > 0.04f) && (harm2Avg[1] > 0.04f) && (harm2Avg[2] > 0.04f)) {
|
||||
harm2Over = true;
|
||||
}
|
||||
if ((harm4Avg[0] > 0.04f) && (harm4Avg[1] > 0.04f) && (harm4Avg[2] > 0.04f)) {
|
||||
harm4Over = true;
|
||||
}
|
||||
|
||||
// 判断2次和4次谐波含量超标(且暂降前偶次谐波)，持续时间超过5个周波，椭圆特征判断为电压调节器
|
||||
if ((harm2Over || harm4Over) && (result.getPreHarmErr() == 0) &&
|
||||
(result.getHoldTime() > (result.getSmp() * 5)) && (result.getBi1() < 0.4f) &&
|
||||
(result.getU3Max() < 1.1f) && (result.getU3Min() > 0.7f)) {
|
||||
|
||||
result.setCause(DataFeature.CAUSE_TYPE2);
|
||||
checkStatus = 7;
|
||||
logger.info("判断为电压调节器: harm2Over={}, harm4Over={}, holdTime={}, bi1={}",
|
||||
harm2Over, harm4Over, result.getHoldTime(), result.getBi1());
|
||||
return checkStatus;
|
||||
} else {
|
||||
result.setCause(DataFeature.CAUSE_TYPE1);
|
||||
checkStatus = 8;
|
||||
logger.info("其他情况判断为短路故障");
|
||||
return checkStatus;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取原因描述
|
||||
* @param cause 原因代码
|
||||
* @return 原因描述
|
||||
*/
|
||||
public static String getCauseDescription(int cause) {
|
||||
switch (cause) {
|
||||
case DataFeature.CAUSE_TYPE0:
|
||||
return "未知原因";
|
||||
case DataFeature.CAUSE_TYPE1:
|
||||
return "短路故障";
|
||||
case DataFeature.CAUSE_TYPE2:
|
||||
return "电压调节器";
|
||||
case DataFeature.CAUSE_TYPE3:
|
||||
return "感应电机启动";
|
||||
case DataFeature.CAUSE_TYPE4:
|
||||
return "电压跌落";
|
||||
default:
|
||||
return "未定义原因";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,283 @@
|
||||
package com.njcn.advance.event.cause.core;
|
||||
|
||||
import com.njcn.advance.event.cause.model.AnalysisResult;
|
||||
import com.njcn.advance.event.cause.model.DataCause;
|
||||
import com.njcn.advance.event.cause.model.DataFeature;
|
||||
import com.njcn.advance.event.cause.model.QvvrDataStruct;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
/**
|
||||
* 电压暂降分析器主类
|
||||
* 对应C语言中的main_pro.c文件的cause_main_app函数
|
||||
*/
|
||||
public class VoltageSagAnalyzer {
|
||||
private static final Logger logger = LoggerFactory.getLogger(VoltageSagAnalyzer.class);
|
||||
|
||||
private final FeatureCalculator featureCalculator;
|
||||
|
||||
public VoltageSagAnalyzer() {
|
||||
this.featureCalculator = new FeatureCalculator();
|
||||
}
|
||||
|
||||
/**
|
||||
* 主要分析函数 - 对应qvvr_fun_cause
|
||||
* @param qvvrData 输入的电压暂降数据结构
|
||||
* @return 处理结果，0表示成功，1表示失败
|
||||
*/
|
||||
public int analyzeVoltageSag(QvvrDataStruct qvvrData) {
|
||||
long startTime = System.currentTimeMillis();
|
||||
|
||||
try {
|
||||
logger.info("开始电压暂降分析，采样率={}，数据长度={}",
|
||||
qvvrData.getSmpRate(), qvvrData.getSmpLen());
|
||||
|
||||
// 参数校验
|
||||
if (!validateInput(qvvrData)) {
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 创建数据处理对象
|
||||
DataCause dataCause = createDataCause(qvvrData);
|
||||
DataFeature resultFeature = new DataFeature();
|
||||
|
||||
// 特征值计算
|
||||
int ret = featureCalculator.calculateFeatures(dataCause, resultFeature);
|
||||
if (ret == 0) {
|
||||
// 阈值判断确定暂降原因
|
||||
int judgeStatus = ThresholdJudge.thresholdJudge(resultFeature);
|
||||
|
||||
// 设置输出结果
|
||||
qvvrData.setCause(resultFeature.getCause());
|
||||
qvvrData.setNoCal(0);
|
||||
|
||||
long processingTime = System.currentTimeMillis() - startTime;
|
||||
logger.info("分析完成，原因={} ({}), 处理时间={}ms, 判断状态={}",
|
||||
resultFeature.getCause(),
|
||||
ThresholdJudge.getCauseDescription(resultFeature.getCause()),
|
||||
processingTime, judgeStatus);
|
||||
|
||||
// 输出详细特征信息
|
||||
logFeatureDetails(resultFeature);
|
||||
|
||||
return 0;
|
||||
} else {
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
logger.error("特征计算失败");
|
||||
return 1;
|
||||
}
|
||||
|
||||
} catch (Exception e) {
|
||||
logger.error("分析过程发生异常", e);
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 输入参数校验
|
||||
* @param qvvrData 输入数据
|
||||
* @return true表示合法，false表示不合法
|
||||
*/
|
||||
private boolean validateInput(QvvrDataStruct qvvrData) {
|
||||
// 首先判断数据个数和采样率是否合理
|
||||
if ((qvvrData.getSmpRate() > FeatureCalculator.MAX_SAMPLE_NUM) ||
|
||||
(qvvrData.getSmpRate() < FeatureCalculator.MIN_SAMPLE_NUM)) {
|
||||
logger.error("采样率超出范围: {}", qvvrData.getSmpRate());
|
||||
return false;
|
||||
}
|
||||
|
||||
if (qvvrData.getSmpLen() > FeatureCalculator.MAX_DATA_LEN) {
|
||||
logger.error("数据长度超出范围: {}", qvvrData.getSmpLen());
|
||||
return false;
|
||||
}
|
||||
|
||||
if (qvvrData.getSmpLen() <= 0) {
|
||||
logger.error("数据长度为空");
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* 创建数据处理对象
|
||||
* @param qvvrData 输入数据结构
|
||||
* @return 数据处理对象
|
||||
*/
|
||||
private DataCause createDataCause(QvvrDataStruct qvvrData) {
|
||||
DataCause dataCause = new DataCause();
|
||||
|
||||
dataCause.setSmp(qvvrData.getSmpRate());
|
||||
dataCause.setF(50.0f); // 默认50Hz工频
|
||||
dataCause.setNum(qvvrData.getSmpLen());
|
||||
|
||||
// 复制电压数据
|
||||
float[] va = new float[qvvrData.getSmpLen()];
|
||||
float[] vb = new float[qvvrData.getSmpLen()];
|
||||
float[] vc = new float[qvvrData.getSmpLen()];
|
||||
float[] t = new float[qvvrData.getSmpLen()];
|
||||
|
||||
System.arraycopy(qvvrData.getSmpVa(), 0, va, 0, qvvrData.getSmpLen());
|
||||
System.arraycopy(qvvrData.getSmpVb(), 0, vb, 0, qvvrData.getSmpLen());
|
||||
System.arraycopy(qvvrData.getSmpVc(), 0, vc, 0, qvvrData.getSmpLen());
|
||||
|
||||
// 生成时间数组
|
||||
for (int i = 0; i < qvvrData.getSmpLen(); i++) {
|
||||
t[i] = (0.02f / dataCause.getSmp()) * i; // 按50Hz周期计算时间
|
||||
}
|
||||
|
||||
dataCause.setVa(va);
|
||||
dataCause.setVb(vb);
|
||||
dataCause.setVc(vc);
|
||||
dataCause.setT(t);
|
||||
|
||||
return dataCause;
|
||||
}
|
||||
|
||||
/**
|
||||
* 输出特征详细信息
|
||||
* @param feature 特征结果
|
||||
*/
|
||||
private void logFeatureDetails(DataFeature feature) {
|
||||
if (logger.isDebugEnabled()) {
|
||||
logger.debug("=== 电压暂降特征分析结果 ===");
|
||||
logger.debug("事件时段: TS={}, TE={}, 持续时间={}个采样点",
|
||||
feature.getTS(), feature.getTE(), feature.getHoldTime());
|
||||
logger.debug("电压特征: 最小值={:.3f}, 最大值={:.3f}",
|
||||
feature.getU3Min(), feature.getU3Max());
|
||||
logger.debug("统计特征: 标准差={:.3f}, 偏度={:.3f}, 峭度={:.3f}",
|
||||
feature.getBiaozhun(), feature.getPian(), feature.getQiao());
|
||||
logger.debug("椭圆特征: bi1={:.3f}, bi2={:.3f}, 高斯性={:.3f}",
|
||||
feature.getBi1(), feature.getBi2(), feature.getGao());
|
||||
logger.debug("相序特征: 负序={:.3f}, 零序={:.3f}, 不平衡度={:.3f}",
|
||||
feature.getU2Avg(), feature.getU0Avg(), feature.getBphAvg());
|
||||
logger.debug("SVD特征: {:.6f}", feature.getSvd());
|
||||
logger.debug("稳态前异常: 不平衡={}, 谐波={}",
|
||||
feature.getPreBphErr(), feature.getPreHarmErr());
|
||||
|
||||
float[] harm2 = feature.getHarm2Avg();
|
||||
float[] harm4 = feature.getHarm4Avg();
|
||||
logger.debug("谐波特征: 2次=({:.3f},{:.3f},{:.3f}), 4次=({:.3f},{:.3f},{:.3f})",
|
||||
harm2[0], harm2[1], harm2[2], harm4[0], harm4[1], harm4[2]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 简化的分析接口 - 直接返回原因代码
|
||||
* @param va A相电压数据
|
||||
* @param vb B相电压数据
|
||||
* @param vc C相电压数据
|
||||
* @param smpRate 采样率
|
||||
* @return 暂降原因代码
|
||||
*/
|
||||
public int analyzeSimple(float[] va, float[] vb, float[] vc, int smpRate) {
|
||||
QvvrDataStruct qvvrData = new QvvrDataStruct();
|
||||
qvvrData.setSmpVa(va);
|
||||
qvvrData.setSmpVb(vb);
|
||||
qvvrData.setSmpVc(vc);
|
||||
qvvrData.setSmpRate(smpRate);
|
||||
qvvrData.setSmpLen(va.length);
|
||||
|
||||
int result = analyzeVoltageSag(qvvrData);
|
||||
if (result == 0) {
|
||||
return qvvrData.getCause();
|
||||
} else {
|
||||
return 0; // 未知原因
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 增强的分析函数 - 返回详细分析结果
|
||||
* @param qvvrData 输入的电压暂降数据结构
|
||||
* @return 包含详细信息的分析结果对象
|
||||
*/
|
||||
public AnalysisResult analyzeVoltageSagWithDetails(QvvrDataStruct qvvrData) {
|
||||
long startTime = System.currentTimeMillis();
|
||||
|
||||
// 构建输入信息描述
|
||||
String inputInfo = String.format("采样率=%d Hz, 数据长度=%d点",
|
||||
qvvrData.getSmpRate(), qvvrData.getSmpLen());
|
||||
|
||||
try {
|
||||
logger.info("开始电压暂降分析，{}", inputInfo);
|
||||
|
||||
// 参数校验
|
||||
if (!validateInput(qvvrData)) {
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
return new AnalysisResult(1, "输入参数校验失败", inputInfo);
|
||||
}
|
||||
|
||||
// 创建数据处理对象
|
||||
DataCause dataCause = createDataCause(qvvrData);
|
||||
DataFeature resultFeature = new DataFeature();
|
||||
|
||||
// 特征值计算
|
||||
int ret = featureCalculator.calculateFeatures(dataCause, resultFeature);
|
||||
if (ret == 0) {
|
||||
// 阈值判断确定暂降原因
|
||||
int judgeStatus = ThresholdJudge.thresholdJudge(resultFeature);
|
||||
|
||||
// 设置输出结果
|
||||
qvvrData.setCause(resultFeature.getCause());
|
||||
qvvrData.setNoCal(0);
|
||||
|
||||
long processingTime = System.currentTimeMillis() - startTime;
|
||||
String causeDescription = ThresholdJudge.getCauseDescription(resultFeature.getCause());
|
||||
|
||||
logger.info("分析完成，原因={} ({}), 处理时间={}ms, 判断状态={}",
|
||||
resultFeature.getCause(), causeDescription, processingTime, judgeStatus);
|
||||
|
||||
// 输出详细特征信息
|
||||
logFeatureDetails(resultFeature);
|
||||
|
||||
// 返回成功结果
|
||||
return new AnalysisResult(resultFeature.getCause(), causeDescription,
|
||||
judgeStatus, processingTime, resultFeature, inputInfo);
|
||||
} else {
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
logger.error("特征计算失败");
|
||||
return new AnalysisResult(1, "特征计算失败", inputInfo);
|
||||
}
|
||||
|
||||
} catch (Exception e) {
|
||||
logger.error("分析过程发生异常", e);
|
||||
qvvrData.setCause(0);
|
||||
qvvrData.setNoCal(1);
|
||||
return new AnalysisResult(1, "分析过程发生异常: " + e.getMessage(), inputInfo);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 简化的详细分析接口 - 直接返回分析结果对象
|
||||
* @param va A相电压数据
|
||||
* @param vb B相电压数据
|
||||
* @param vc C相电压数据
|
||||
* @param smpRate 采样率
|
||||
* @return 包含详细信息的分析结果对象
|
||||
*/
|
||||
public AnalysisResult analyzeWithDetails(float[] va, float[] vb, float[] vc, int smpRate) {
|
||||
QvvrDataStruct qvvrData = new QvvrDataStruct();
|
||||
qvvrData.setSmpVa(va);
|
||||
qvvrData.setSmpVb(vb);
|
||||
qvvrData.setSmpVc(vc);
|
||||
qvvrData.setSmpRate(smpRate);
|
||||
qvvrData.setSmpLen(va.length);
|
||||
|
||||
return analyzeVoltageSagWithDetails(qvvrData);
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取分析器版本信息
|
||||
* @return 版本字符串
|
||||
*/
|
||||
public String getVersion() {
|
||||
return "Java Voltage Sag Analyzer v1.0.0 - Converted from C implementation";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package com.njcn.advance.event.cause.io;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
|
||||
/**
|
||||
* COMTRADE格式数据文件读取器
|
||||
* 对应C语言中的comtrade_read函数
|
||||
*/
|
||||
public class ComtradeReader {
|
||||
private static final Logger logger = LoggerFactory.getLogger(ComtradeReader.class);
|
||||
|
||||
/**
|
||||
* COMTRADE数据读取结果
|
||||
*/
|
||||
public static class ComtradeData {
|
||||
private float[] ua;
|
||||
private float[] ub;
|
||||
private float[] uc;
|
||||
private int sampleCount;
|
||||
private int sampleRate;
|
||||
|
||||
public ComtradeData(float[] ua, float[] ub, float[] uc, int sampleCount, int sampleRate) {
|
||||
this.ua = ua;
|
||||
this.ub = ub;
|
||||
this.uc = uc;
|
||||
this.sampleCount = sampleCount;
|
||||
this.sampleRate = sampleRate;
|
||||
}
|
||||
|
||||
public float[] getUa() { return ua; }
|
||||
public float[] getUb() { return ub; }
|
||||
public float[] getUc() { return uc; }
|
||||
public int getSampleCount() { return sampleCount; }
|
||||
public int getSampleRate() { return sampleRate; }
|
||||
}
|
||||
|
||||
/**
|
||||
* 读取COMTRADE格式的DAT文件
|
||||
* @param filename 文件名
|
||||
* @param xsa A相比例因子
|
||||
* @param xsb B相比例因子
|
||||
* @param xsc C相比例因子
|
||||
* @param inputSampleRate 输入采样率
|
||||
* @param outputSampleRate 输出采样率
|
||||
* @param maxSamples 最大采样点数
|
||||
* @param recordSize 每个记录的字节数（20或14）
|
||||
* @return COMTRADE数据对象
|
||||
* @throws IOException 文件读取异常
|
||||
*/
|
||||
public static ComtradeData readComtradeFile(String filename,
|
||||
float xsa, float xsb, float xsc,
|
||||
int inputSampleRate, int outputSampleRate,
|
||||
int maxSamples, int recordSize) throws IOException {
|
||||
|
||||
logger.info("开始读取COMTRADE文件: {}", filename);
|
||||
logger.info("参数: xsa={}, xsb={}, xsc={}, 输入采样率={}, 输出采样率={}, 记录大小={}字节",
|
||||
xsa, xsb, xsc, inputSampleRate, outputSampleRate, recordSize);
|
||||
|
||||
File file = new File(filename);
|
||||
if (!file.exists()) {
|
||||
throw new IOException("文件不存在: " + filename);
|
||||
}
|
||||
|
||||
long fileSize = file.length();
|
||||
int recordCount = (int)(fileSize / recordSize);
|
||||
|
||||
logger.info("文件大小: {} 字节, 记录数: {}", fileSize, recordCount);
|
||||
|
||||
// 读取文件数据
|
||||
byte[] buffer = new byte[(int)fileSize];
|
||||
try (FileInputStream fis = new FileInputStream(file)) {
|
||||
int bytesRead = fis.read(buffer);
|
||||
if (bytesRead != fileSize) {
|
||||
throw new IOException("文件读取不完整");
|
||||
}
|
||||
}
|
||||
|
||||
// 解析数据
|
||||
float[] ua = new float[maxSamples];
|
||||
float[] ub = new float[maxSamples];
|
||||
float[] uc = new float[maxSamples];
|
||||
|
||||
int dataCount = 0;
|
||||
int decimationMod = inputSampleRate / outputSampleRate;
|
||||
|
||||
ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
|
||||
byteBuffer.order(ByteOrder.LITTLE_ENDIAN); // 小端字节序
|
||||
|
||||
for (int i = 0; i < recordCount && dataCount < maxSamples; i++) {
|
||||
// 根据采样率转换决定是否处理此记录
|
||||
if (inputSampleRate == outputSampleRate || (i % decimationMod) == 0) {
|
||||
|
||||
int baseOffset = i * recordSize;
|
||||
|
||||
// 读取三相电压数据（从第8字节开始，每相2字节）
|
||||
short dataA = byteBuffer.getShort(baseOffset + 8);
|
||||
short dataB = byteBuffer.getShort(baseOffset + 10);
|
||||
short dataC = byteBuffer.getShort(baseOffset + 12);
|
||||
|
||||
// 应用比例因子
|
||||
ua[dataCount] = dataA * xsa;
|
||||
ub[dataCount] = dataB * xsb;
|
||||
uc[dataCount] = dataC * xsc;
|
||||
|
||||
dataCount++;
|
||||
}
|
||||
}
|
||||
|
||||
logger.info("成功读取 {} 个数据点", dataCount);
|
||||
|
||||
return new ComtradeData(ua, ub, uc, dataCount, outputSampleRate);
|
||||
}
|
||||
|
||||
/**
|
||||
* 使用默认参数读取1.dat文件 - 对应C代码中的smp_data_init函数
|
||||
* @param filename 文件名
|
||||
* @return COMTRADE数据对象
|
||||
* @throws IOException 文件读取异常
|
||||
*/
|
||||
public static ComtradeData readDefault(String filename) throws IOException {
|
||||
// 使用C代码中的默认参数
|
||||
float[] xs = {0.062256f, 0.062250f, 0.062262f};
|
||||
int inputSampleRate = 256;
|
||||
int outputSampleRate = 128;
|
||||
int maxSamples = 10000; // MAX_SMP_DATA_LEN的合理值
|
||||
int recordSize = 14; // C代码中dev=1，所以使用14字节/记录
|
||||
|
||||
return readComtradeFile(filename, xs[0], xs[1], xs[2],
|
||||
inputSampleRate, outputSampleRate, maxSamples, recordSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* 检查DAT文件是否存在
|
||||
* @param filename 文件名
|
||||
* @return 文件是否存在
|
||||
*/
|
||||
public static boolean isDatFileExists(String filename) {
|
||||
return new File(filename).exists();
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取DAT文件信息
|
||||
* @param filename 文件名
|
||||
* @return 文件信息字符串
|
||||
*/
|
||||
public static String getDatFileInfo(String filename) {
|
||||
File file = new File(filename);
|
||||
if (!file.exists()) {
|
||||
return "文件不存在: " + filename;
|
||||
}
|
||||
|
||||
long fileSize = file.length();
|
||||
int recordCount20 = (int)(fileSize / 20);
|
||||
int recordCount14 = (int)(fileSize / 14);
|
||||
|
||||
return String.format("文件: %s, 大小: %d 字节, 可能记录数: %d (20字节/记录) 或 %d (14字节/记录)",
|
||||
filename, fileSize, recordCount20, recordCount14);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 电压暂降分析结果类
|
||||
* 包含处理状态和详细分析信息
|
||||
*/
|
||||
public class AnalysisResult {
|
||||
|
||||
/**
|
||||
* 处理结果状态码
|
||||
*/
|
||||
private int status;
|
||||
|
||||
/**
|
||||
* 电压暂降原因代码
|
||||
*/
|
||||
private int cause;
|
||||
|
||||
/**
|
||||
* 原因描述字符串
|
||||
*/
|
||||
private String causeDescription;
|
||||
|
||||
/**
|
||||
* 判断状态码（算法内部路径）
|
||||
*/
|
||||
private int judgeStatus;
|
||||
|
||||
/**
|
||||
* 处理时间（毫秒）
|
||||
*/
|
||||
private long processingTime;
|
||||
|
||||
/**
|
||||
* 错误信息（失败时）
|
||||
*/
|
||||
private String errorMessage;
|
||||
|
||||
/**
|
||||
* 详细特征信息
|
||||
*/
|
||||
private DataFeature features;
|
||||
|
||||
/**
|
||||
* 输入数据基本信息
|
||||
*/
|
||||
private String inputInfo;
|
||||
|
||||
/**
|
||||
* 构造函数 - 成功结果
|
||||
*/
|
||||
public AnalysisResult(int cause, String causeDescription, int judgeStatus,
|
||||
long processingTime, DataFeature features, String inputInfo) {
|
||||
this.status = 0; // 成功
|
||||
this.cause = cause;
|
||||
this.causeDescription = causeDescription;
|
||||
this.judgeStatus = judgeStatus;
|
||||
this.processingTime = processingTime;
|
||||
this.features = features;
|
||||
this.inputInfo = inputInfo;
|
||||
this.errorMessage = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 构造函数 - 失败结果
|
||||
*/
|
||||
public AnalysisResult(int status, String errorMessage, String inputInfo) {
|
||||
this.status = status;
|
||||
this.cause = 0; // 未知原因
|
||||
this.causeDescription = "未知原因";
|
||||
this.judgeStatus = -1;
|
||||
this.processingTime = 0;
|
||||
this.features = null;
|
||||
this.inputInfo = inputInfo;
|
||||
this.errorMessage = errorMessage;
|
||||
}
|
||||
|
||||
// Getters
|
||||
public int getStatus() { return status; }
|
||||
public int getCause() { return cause; }
|
||||
public String getCauseDescription() { return causeDescription; }
|
||||
public int getJudgeStatus() { return judgeStatus; }
|
||||
public long getProcessingTime() { return processingTime; }
|
||||
public String getErrorMessage() { return errorMessage; }
|
||||
public DataFeature getFeatures() { return features; }
|
||||
public String getInputInfo() { return inputInfo; }
|
||||
|
||||
/**
|
||||
* 是否成功
|
||||
*/
|
||||
public boolean isSuccess() {
|
||||
return status == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取判断路径描述
|
||||
*/
|
||||
public String getJudgeStatusDescription() {
|
||||
switch (judgeStatus) {
|
||||
case 1: return "暂降前不平衡异常";
|
||||
case 2: return "短时浅暂降判断为电压跌落";
|
||||
case 3: return "单相接地短路特征";
|
||||
case 4: return "不对称故障特征";
|
||||
case 5: return "感应电机启动特征（长时间+低SVD）";
|
||||
case 6: return "三相对称短路故障";
|
||||
case 7: return "电压调节器特征（谐波超标）";
|
||||
case 8: return "其他情况归类为短路故障";
|
||||
case 9: return "电压严重超限判断为短路故障";
|
||||
case 10: return "短时严重暂降判断为短路故障";
|
||||
default: return "未知判断路径";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取完整的分析摘要
|
||||
*/
|
||||
public String getSummary() {
|
||||
if (!isSuccess()) {
|
||||
return String.format("分析失败: %s\n输入信息: %s", errorMessage, inputInfo);
|
||||
}
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append("=== 电压暂降分析结果 ===\n");
|
||||
sb.append(String.format("输入信息: %s\n", inputInfo));
|
||||
sb.append(String.format("分析结果: %s (代码: %d)\n", causeDescription, cause));
|
||||
sb.append(String.format("判断路径: %s (状态码: %d)\n", getJudgeStatusDescription(), judgeStatus));
|
||||
sb.append(String.format("处理时间: %d ms\n", processingTime));
|
||||
|
||||
if (features != null) {
|
||||
sb.append(String.format("事件时段: TS=%d, TE=%d, 持续时间=%d个采样点\n",
|
||||
features.getTS(), features.getTE(), features.getHoldTime()));
|
||||
sb.append(String.format("电压特征: 最小值=%.3f, 最大值=%.3f\n",
|
||||
features.getU3Min(), features.getU3Max()));
|
||||
sb.append(String.format("相序特征: 负序=%.3f, 零序=%.3f, 不平衡度=%.3f\n",
|
||||
features.getU2Avg(), features.getU0Avg(), features.getBphAvg()));
|
||||
sb.append(String.format("椭圆特征: bi1=%.3f, bi2=%.3f\n",
|
||||
features.getBi1(), features.getBi2()));
|
||||
sb.append(String.format("SVD特征: %.6f\n", features.getSvd()));
|
||||
}
|
||||
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getSummary();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 复数结构
|
||||
* 对应C语言中的complex结构体
|
||||
*/
|
||||
public class Complex {
|
||||
private double real; // 实部
|
||||
private double imag; // 虚部
|
||||
|
||||
public Complex() {
|
||||
this(0.0, 0.0);
|
||||
}
|
||||
|
||||
public Complex(double real, double imag) {
|
||||
this.real = real;
|
||||
this.imag = imag;
|
||||
}
|
||||
|
||||
// 复数加法
|
||||
public Complex plus(Complex other) {
|
||||
return new Complex(this.real + other.real, this.imag + other.imag);
|
||||
}
|
||||
|
||||
// 复数减法
|
||||
public Complex minus(Complex other) {
|
||||
return new Complex(this.real - other.real, this.imag - other.imag);
|
||||
}
|
||||
|
||||
// 复数乘法
|
||||
public Complex multiply(Complex other) {
|
||||
double newReal = this.real * other.real - this.imag * other.imag;
|
||||
double newImag = this.real * other.imag + this.imag * other.real;
|
||||
return new Complex(newReal, newImag);
|
||||
}
|
||||
|
||||
// 复数除法
|
||||
public Complex divide(Complex other) {
|
||||
double denominator = other.real * other.real + other.imag * other.imag;
|
||||
if (Math.abs(denominator) < 1e-10) {
|
||||
throw new ArithmeticException("Division by zero complex number");
|
||||
}
|
||||
double newReal = (this.real * other.real + this.imag * other.imag) / denominator;
|
||||
double newImag = (this.imag * other.real - this.real * other.imag) / denominator;
|
||||
return new Complex(newReal, newImag);
|
||||
}
|
||||
|
||||
// 复数模
|
||||
public double abs() {
|
||||
return Math.sqrt(real * real + imag * imag);
|
||||
}
|
||||
|
||||
// 复数共轭
|
||||
public Complex conjugate() {
|
||||
return new Complex(real, -imag);
|
||||
}
|
||||
|
||||
// 复数幅角
|
||||
public double phase() {
|
||||
return Math.atan2(imag, real);
|
||||
}
|
||||
|
||||
// Getters and Setters
|
||||
public double getReal() {
|
||||
return real;
|
||||
}
|
||||
|
||||
public void setReal(double real) {
|
||||
this.real = real;
|
||||
}
|
||||
|
||||
public double getImag() {
|
||||
return imag;
|
||||
}
|
||||
|
||||
public void setImag(double imag) {
|
||||
this.imag = imag;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
if (imag >= 0) {
|
||||
return String.format("%.6f + %.6fi", real, imag);
|
||||
} else {
|
||||
return String.format("%.6f - %.6fi", real, -imag);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 数据原因分析结构
|
||||
* 对应C语言中的data_cause
|
||||
*/
|
||||
public class DataCause {
|
||||
public static final int MAX_DATA_LEN = 128 * 50 * 60;
|
||||
|
||||
// 原始采样数据
|
||||
private float[] va = new float[MAX_DATA_LEN];
|
||||
private float[] vb = new float[MAX_DATA_LEN];
|
||||
private float[] vc = new float[MAX_DATA_LEN];
|
||||
private float[] t = new float[MAX_DATA_LEN];
|
||||
|
||||
// 计算出的有效值
|
||||
private float[] rmsa = new float[MAX_DATA_LEN];
|
||||
private float[] rmsb = new float[MAX_DATA_LEN];
|
||||
private float[] rmsc = new float[MAX_DATA_LEN];
|
||||
private float[] rmsMin = new float[MAX_DATA_LEN];
|
||||
private float[] rmsMax = new float[MAX_DATA_LEN];
|
||||
|
||||
// dq变换幅值
|
||||
private float[] ua = new float[MAX_DATA_LEN];
|
||||
private float[] ub = new float[MAX_DATA_LEN];
|
||||
private float[] uc = new float[MAX_DATA_LEN];
|
||||
|
||||
private float[] ua0 = new float[MAX_DATA_LEN];
|
||||
private float[] ub0 = new float[MAX_DATA_LEN];
|
||||
private float[] uc0 = new float[MAX_DATA_LEN];
|
||||
|
||||
// dq变换相位
|
||||
private float[] anga = new float[MAX_DATA_LEN];
|
||||
private float[] angb = new float[MAX_DATA_LEN];
|
||||
private float[] angc = new float[MAX_DATA_LEN];
|
||||
|
||||
// dq变换相量
|
||||
private VecStruct[] phasora = new VecStruct[MAX_DATA_LEN];
|
||||
private VecStruct[] phasorb = new VecStruct[MAX_DATA_LEN];
|
||||
private VecStruct[] phasorc = new VecStruct[MAX_DATA_LEN];
|
||||
|
||||
private int smp; // 采样率
|
||||
private int num; // 数据点数
|
||||
private float f; // 频率
|
||||
private float un; // 额定电压
|
||||
|
||||
// Constructor
|
||||
public DataCause() {
|
||||
// 初始化相量数组
|
||||
for (int i = 0; i < MAX_DATA_LEN; i++) {
|
||||
phasora[i] = new VecStruct();
|
||||
phasorb[i] = new VecStruct();
|
||||
phasorc[i] = new VecStruct();
|
||||
}
|
||||
}
|
||||
|
||||
// Getters and Setters
|
||||
public float[] getVa() { return va; }
|
||||
public void setVa(float[] va) {
|
||||
System.arraycopy(va, 0, this.va, 0, Math.min(va.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getVb() { return vb; }
|
||||
public void setVb(float[] vb) {
|
||||
System.arraycopy(vb, 0, this.vb, 0, Math.min(vb.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getVc() { return vc; }
|
||||
public void setVc(float[] vc) {
|
||||
System.arraycopy(vc, 0, this.vc, 0, Math.min(vc.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getT() { return t; }
|
||||
public void setT(float[] t) {
|
||||
System.arraycopy(t, 0, this.t, 0, Math.min(t.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getRmsa() { return rmsa; }
|
||||
public void setRmsa(float[] rmsa) {
|
||||
System.arraycopy(rmsa, 0, this.rmsa, 0, Math.min(rmsa.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getRmsb() { return rmsb; }
|
||||
public void setRmsb(float[] rmsb) {
|
||||
System.arraycopy(rmsb, 0, this.rmsb, 0, Math.min(rmsb.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getRmsc() { return rmsc; }
|
||||
public void setRmsc(float[] rmsc) {
|
||||
System.arraycopy(rmsc, 0, this.rmsc, 0, Math.min(rmsc.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getRmsMin() { return rmsMin; }
|
||||
public void setRmsMin(float[] rmsMin) {
|
||||
System.arraycopy(rmsMin, 0, this.rmsMin, 0, Math.min(rmsMin.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getRmsMax() { return rmsMax; }
|
||||
public void setRmsMax(float[] rmsMax) {
|
||||
System.arraycopy(rmsMax, 0, this.rmsMax, 0, Math.min(rmsMax.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUa() { return ua; }
|
||||
public void setUa(float[] ua) {
|
||||
System.arraycopy(ua, 0, this.ua, 0, Math.min(ua.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUb() { return ub; }
|
||||
public void setUb(float[] ub) {
|
||||
System.arraycopy(ub, 0, this.ub, 0, Math.min(ub.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUc() { return uc; }
|
||||
public void setUc(float[] uc) {
|
||||
System.arraycopy(uc, 0, this.uc, 0, Math.min(uc.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUa0() { return ua0; }
|
||||
public void setUa0(float[] ua0) {
|
||||
System.arraycopy(ua0, 0, this.ua0, 0, Math.min(ua0.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUb0() { return ub0; }
|
||||
public void setUb0(float[] ub0) {
|
||||
System.arraycopy(ub0, 0, this.ub0, 0, Math.min(ub0.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getUc0() { return uc0; }
|
||||
public void setUc0(float[] uc0) {
|
||||
System.arraycopy(uc0, 0, this.uc0, 0, Math.min(uc0.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getAnga() { return anga; }
|
||||
public void setAnga(float[] anga) {
|
||||
System.arraycopy(anga, 0, this.anga, 0, Math.min(anga.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getAngb() { return angb; }
|
||||
public void setAngb(float[] angb) {
|
||||
System.arraycopy(angb, 0, this.angb, 0, Math.min(angb.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public float[] getAngc() { return angc; }
|
||||
public void setAngc(float[] angc) {
|
||||
System.arraycopy(angc, 0, this.angc, 0, Math.min(angc.length, MAX_DATA_LEN));
|
||||
}
|
||||
|
||||
public VecStruct[] getPhasora() { return phasora; }
|
||||
public VecStruct[] getPhasorb() { return phasorb; }
|
||||
public VecStruct[] getPhasorc() { return phasorc; }
|
||||
|
||||
public int getSmp() { return smp; }
|
||||
public void setSmp(int smp) { this.smp = smp; }
|
||||
|
||||
public int getNum() { return num; }
|
||||
public void setNum(int num) { this.num = num; }
|
||||
|
||||
public float getF() { return f; }
|
||||
public void setF(float f) { this.f = f; }
|
||||
|
||||
public float getUn() { return un; }
|
||||
public void setUn(float un) { this.un = un; }
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 数据特征结构
|
||||
* 对应C语言中的data_feature
|
||||
*/
|
||||
public class DataFeature {
|
||||
// 暂降原因定义
|
||||
public static final int CAUSE_TYPE0 = 0; // 未知
|
||||
public static final int CAUSE_TYPE1 = 1; // 短路故障
|
||||
public static final int CAUSE_TYPE2 = 2; // 电压调节器
|
||||
public static final int CAUSE_TYPE3 = 3; // 感动电机
|
||||
public static final int CAUSE_TYPE4 = 4; // 电压跌落
|
||||
|
||||
|
||||
// 暂降类型定义
|
||||
public static final int TYPE0 = 0; // BC相间故障
|
||||
public static final int TYPE1 = 1; // C相接地故障
|
||||
public static final int TYPE2 = 2; // AC相间故障
|
||||
public static final int TYPE3 = 3; // A相接地故障
|
||||
public static final int TYPE4 = 4; // AB相间故障
|
||||
public static final int TYPE5 = 5; // B相接地故障
|
||||
public static final int TYPE6 = 6; // BC相间接地
|
||||
public static final int TYPE7 = 7; // AC相间接地
|
||||
public static final int TYPE8 = 8; // AB相间接地
|
||||
public static final int TYPE9 = 9; // 三相故障
|
||||
public static final int TYPE10 = 10; // 未知
|
||||
|
||||
|
||||
private int TS; // 暂降开始时刻
|
||||
private int TE; // 暂降结束时刻
|
||||
private int smp; // 采样率
|
||||
private float UN; // 系统额定电压
|
||||
|
||||
// 特征参数
|
||||
private int preBphErr; // 稳态前电气平衡异常标志
|
||||
private int preHarmErr; // 稳态前偶次谐波异常标志
|
||||
private int uLow50; // 稳态事件期间三相中低于50%额值持续一个周波以上
|
||||
private int uHigh120; // 稳态事件期间三相中高于120%额值持续一个周波以上
|
||||
private int holdTime; // 持续时间（按照周波计算）
|
||||
private float u3Max; // 暂降期电压有效值最大值
|
||||
private float u3Min; // 最小值（标幺）
|
||||
private float[] uMin = new float[3]; // 三相最小值
|
||||
private float gao; // 高斯性
|
||||
private float bi1; // 椭圆特征bi1
|
||||
private float bi2; // 椭圆特征bi2
|
||||
private float biaozhun; // 统计特征-标准差
|
||||
private float pian; // 统计特征-偏度
|
||||
private float qiao; // 统计特征-峭度
|
||||
|
||||
private float u2Max; // 负序电压最大值（相对un百分比）
|
||||
private float u2Avg; // 负序电压平均值（相对un百分比）
|
||||
private float u0Max; // 零序电压最大值（相对un百分比）
|
||||
private float u0Avg; // 零序电压平均值（相对un百分比）
|
||||
private float bphMax; // 不平衡度%
|
||||
private float bphAvg; // 不平衡度%
|
||||
|
||||
private float[] harm2Max = new float[3]; // 2次谐波三相的最大值 相对un
|
||||
private float[] harm4Max = new float[3]; // 4次谐波三相的最大值 相对un
|
||||
private float[] harm2Avg = new float[3]; // 2次谐波三相平均值 相对un
|
||||
private float[] harm4Avg = new float[3]; // 4次谐波三相平均值 相对un
|
||||
|
||||
private float svd; // 奇异值
|
||||
|
||||
// 结果
|
||||
private int cause; // 电压暂降分类暂降原因
|
||||
|
||||
// Constructors
|
||||
public DataFeature() {
|
||||
this.cause = CAUSE_TYPE0;
|
||||
}
|
||||
|
||||
// Getters and Setters
|
||||
public int getTS() { return TS; }
|
||||
public void setTS(int TS) { this.TS = TS; }
|
||||
|
||||
public int getTE() { return TE; }
|
||||
public void setTE(int TE) { this.TE = TE; }
|
||||
|
||||
public int getSmp() { return smp; }
|
||||
public void setSmp(int smp) { this.smp = smp; }
|
||||
|
||||
public float getUN() { return UN; }
|
||||
public void setUN(float UN) { this.UN = UN; }
|
||||
|
||||
public int getPreBphErr() { return preBphErr; }
|
||||
public void setPreBphErr(int preBphErr) { this.preBphErr = preBphErr; }
|
||||
|
||||
public int getPreHarmErr() { return preHarmErr; }
|
||||
public void setPreHarmErr(int preHarmErr) { this.preHarmErr = preHarmErr; }
|
||||
|
||||
public int getuLow50() { return uLow50; }
|
||||
public void setuLow50(int uLow50) { this.uLow50 = uLow50; }
|
||||
|
||||
public int getuHigh120() { return uHigh120; }
|
||||
public void setuHigh120(int uHigh120) { this.uHigh120 = uHigh120; }
|
||||
|
||||
public int getHoldTime() { return holdTime; }
|
||||
public void setHoldTime(int holdTime) { this.holdTime = holdTime; }
|
||||
|
||||
public float getU3Max() { return u3Max; }
|
||||
public void setU3Max(float u3Max) { this.u3Max = u3Max; }
|
||||
|
||||
public float getU3Min() { return u3Min; }
|
||||
public void setU3Min(float u3Min) { this.u3Min = u3Min; }
|
||||
|
||||
public float[] getUMin() { return uMin; }
|
||||
public void setUMin(float[] uMin) { System.arraycopy(uMin, 0, this.uMin, 0, Math.min(uMin.length, 3)); }
|
||||
|
||||
public float getGao() { return gao; }
|
||||
public void setGao(float gao) { this.gao = gao; }
|
||||
|
||||
public float getBi1() { return bi1; }
|
||||
public void setBi1(float bi1) { this.bi1 = bi1; }
|
||||
|
||||
public float getBi2() { return bi2; }
|
||||
public void setBi2(float bi2) { this.bi2 = bi2; }
|
||||
|
||||
public float getBiaozhun() { return biaozhun; }
|
||||
public void setBiaozhun(float biaozhun) { this.biaozhun = biaozhun; }
|
||||
|
||||
public float getPian() { return pian; }
|
||||
public void setPian(float pian) { this.pian = pian; }
|
||||
|
||||
public float getQiao() { return qiao; }
|
||||
public void setQiao(float qiao) { this.qiao = qiao; }
|
||||
|
||||
public float getU2Max() { return u2Max; }
|
||||
public void setU2Max(float u2Max) { this.u2Max = u2Max; }
|
||||
|
||||
public float getU2Avg() { return u2Avg; }
|
||||
public void setU2Avg(float u2Avg) { this.u2Avg = u2Avg; }
|
||||
|
||||
public float getU0Max() { return u0Max; }
|
||||
public void setU0Max(float u0Max) { this.u0Max = u0Max; }
|
||||
|
||||
public float getU0Avg() { return u0Avg; }
|
||||
public void setU0Avg(float u0Avg) { this.u0Avg = u0Avg; }
|
||||
|
||||
public float getBphMax() { return bphMax; }
|
||||
public void setBphMax(float bphMax) { this.bphMax = bphMax; }
|
||||
|
||||
public float getBphAvg() { return bphAvg; }
|
||||
public void setBphAvg(float bphAvg) { this.bphAvg = bphAvg; }
|
||||
|
||||
public float[] getHarm2Max() { return harm2Max; }
|
||||
public void setHarm2Max(float[] harm2Max) { System.arraycopy(harm2Max, 0, this.harm2Max, 0, Math.min(harm2Max.length, 3)); }
|
||||
|
||||
public float[] getHarm4Max() { return harm4Max; }
|
||||
public void setHarm4Max(float[] harm4Max) { System.arraycopy(harm4Max, 0, this.harm4Max, 0, Math.min(harm4Max.length, 3)); }
|
||||
|
||||
public float[] getHarm2Avg() { return harm2Avg; }
|
||||
public void setHarm2Avg(float[] harm2Avg) { System.arraycopy(harm2Avg, 0, this.harm2Avg, 0, Math.min(harm2Avg.length, 3)); }
|
||||
|
||||
public float[] getHarm4Avg() { return harm4Avg; }
|
||||
public void setHarm4Avg(float[] harm4Avg) { System.arraycopy(harm4Avg, 0, this.harm4Avg, 0, Math.min(harm4Avg.length, 3)); }
|
||||
|
||||
public float getSvd() { return svd; }
|
||||
public void setSvd(float svd) { this.svd = svd; }
|
||||
|
||||
public int getCause() { return cause; }
|
||||
public void setCause(int cause) { this.cause = cause; }
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 电压暂降数据结构
|
||||
* 对应C语言中的qvvr_data_struct
|
||||
*/
|
||||
public class QvvrDataStruct {
|
||||
public static final int MAX_SMP_DATA_LEN = 128 * 50 * 120;
|
||||
|
||||
// 输入参数定义
|
||||
private float[] smpVa = new float[MAX_SMP_DATA_LEN]; // A相电压采样数据
|
||||
private float[] smpVb = new float[MAX_SMP_DATA_LEN]; // B相电压采样数据
|
||||
private float[] smpVc = new float[MAX_SMP_DATA_LEN]; // C相电压采样数据
|
||||
private int smpRate; // 采样率参数
|
||||
private int smpLen; // 每个通道的采样数据个数
|
||||
|
||||
// 输入阈值参数
|
||||
private float[] threshold = new float[50]; // 预设阈值时间参数
|
||||
|
||||
// 输出结果参数定义
|
||||
private int cause; // 电压暂降判断出暂降原因 0-未知,1-短路,2-电压调节器,3-感动电机
|
||||
private int noCal; // 未计算判断标志，该位1表示输入数据有问题
|
||||
|
||||
// Constructors
|
||||
public QvvrDataStruct() {
|
||||
this.cause = 0;
|
||||
this.noCal = 0;
|
||||
}
|
||||
|
||||
// Getters and Setters
|
||||
public float[] getSmpVa() {
|
||||
return smpVa;
|
||||
}
|
||||
|
||||
public void setSmpVa(float[] smpVa) {
|
||||
if (smpVa.length <= MAX_SMP_DATA_LEN) {
|
||||
System.arraycopy(smpVa, 0, this.smpVa, 0, smpVa.length);
|
||||
}
|
||||
}
|
||||
|
||||
public float[] getSmpVb() {
|
||||
return smpVb;
|
||||
}
|
||||
|
||||
public void setSmpVb(float[] smpVb) {
|
||||
if (smpVb.length <= MAX_SMP_DATA_LEN) {
|
||||
System.arraycopy(smpVb, 0, this.smpVb, 0, smpVb.length);
|
||||
}
|
||||
}
|
||||
|
||||
public float[] getSmpVc() {
|
||||
return smpVc;
|
||||
}
|
||||
|
||||
public void setSmpVc(float[] smpVc) {
|
||||
if (smpVc.length <= MAX_SMP_DATA_LEN) {
|
||||
System.arraycopy(smpVc, 0, this.smpVc, 0, smpVc.length);
|
||||
}
|
||||
}
|
||||
|
||||
public int getSmpRate() {
|
||||
return smpRate;
|
||||
}
|
||||
|
||||
public void setSmpRate(int smpRate) {
|
||||
this.smpRate = smpRate;
|
||||
}
|
||||
|
||||
public int getSmpLen() {
|
||||
return smpLen;
|
||||
}
|
||||
|
||||
public void setSmpLen(int smpLen) {
|
||||
this.smpLen = smpLen;
|
||||
}
|
||||
|
||||
public float[] getThreshold() {
|
||||
return threshold;
|
||||
}
|
||||
|
||||
public void setThreshold(float[] threshold) {
|
||||
if (threshold.length <= 50) {
|
||||
System.arraycopy(threshold, 0, this.threshold, 0, threshold.length);
|
||||
}
|
||||
}
|
||||
|
||||
public int getCause() {
|
||||
return cause;
|
||||
}
|
||||
|
||||
public void setCause(int cause) {
|
||||
this.cause = cause;
|
||||
}
|
||||
|
||||
public int getNoCal() {
|
||||
return noCal;
|
||||
}
|
||||
|
||||
public void setNoCal(int noCal) {
|
||||
this.noCal = noCal;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package com.njcn.advance.event.cause.model;
|
||||
|
||||
/**
|
||||
* 向量结构
|
||||
* 对应C语言中的vec_struct
|
||||
*/
|
||||
public class VecStruct {
|
||||
private float r; // 实部
|
||||
private float x; // 虚部
|
||||
|
||||
public VecStruct() {
|
||||
this(0.0f, 0.0f);
|
||||
}
|
||||
|
||||
public VecStruct(float r, float x) {
|
||||
this.r = r;
|
||||
this.x = x;
|
||||
}
|
||||
|
||||
// 向量模长
|
||||
public float magnitude() {
|
||||
return (float) Math.sqrt(r * r + x * x);
|
||||
}
|
||||
|
||||
// 向量相角
|
||||
public float phase() {
|
||||
return (float) Math.atan2(x, r);
|
||||
}
|
||||
|
||||
// Getters and Setters
|
||||
public float getR() {
|
||||
return r;
|
||||
}
|
||||
|
||||
public void setR(float r) {
|
||||
this.r = r;
|
||||
}
|
||||
|
||||
public float getX() {
|
||||
return x;
|
||||
}
|
||||
|
||||
public void setX(float x) {
|
||||
this.x = x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("VecStruct{r=%.6f, x=%.6f}", r, x);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.njcn.advance.event.controller;
|
||||
|
||||
import com.njcn.advance.event.pojo.EventAnalysisDTO;
|
||||
import com.njcn.advance.event.service.IEventAdvanceService;
|
||||
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.ApiOperation;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.web.bind.annotation.PostMapping;
|
||||
import org.springframework.web.bind.annotation.RequestMapping;
|
||||
import org.springframework.web.bind.annotation.RestController;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* @author hongawen
|
||||
* @version 1.0
|
||||
* @data 2025/7/30 10:38
|
||||
*/
|
||||
@Slf4j
|
||||
@RestController
|
||||
@RequestMapping("/eventAdvance")
|
||||
@Api(tags = "暂降高级分析")
|
||||
@RequiredArgsConstructor
|
||||
public class EventCauseController extends BaseController {
|
||||
|
||||
private final IEventAdvanceService eventAdvanceService;
|
||||
|
||||
@PostMapping(value = "/analysisCauseAndType")
|
||||
@ApiOperation("分析暂降事件的原因和类型")
|
||||
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
|
||||
public HttpResult<EventAnalysisDTO> analysisCauseAndType(EventAnalysisDTO eventAnalysis) {
|
||||
String methodDescribe = getMethodDescribe("analysisCauseAndType");
|
||||
eventAnalysis = eventAdvanceService.analysisCauseAndType(eventAnalysis);
|
||||
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, eventAnalysis, methodDescribe);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package com.njcn.advance.event.pojo;
|
||||
|
||||
import lombok.Data;
|
||||
|
||||
/**
|
||||
*
|
||||
* 暂降事件的高级分析，包括暂降原因和暂降类型
|
||||
*
|
||||
* @author hongawen
|
||||
* @version 1.0
|
||||
* @data 2025/7/30 10:43
|
||||
*/
|
||||
@Data
|
||||
public class EventAnalysisDTO {
|
||||
|
||||
/**
|
||||
* lineId
|
||||
*/
|
||||
private String lineId;
|
||||
|
||||
/**
|
||||
* 监测点IP
|
||||
*/
|
||||
private String ip;
|
||||
|
||||
/**
|
||||
* 事件ID
|
||||
*/
|
||||
private String eventId;
|
||||
|
||||
/**
|
||||
* 文件名称
|
||||
*/
|
||||
private String waveName;
|
||||
|
||||
/**
|
||||
* 暂降原因
|
||||
* (0) //未知
|
||||
* (1) //短路故障
|
||||
* (2) //电压调节器
|
||||
* (3) //感动电机
|
||||
* (4) //电压跌落
|
||||
*/
|
||||
private Integer cause;
|
||||
|
||||
|
||||
/**
|
||||
* 可能分析失败，虽然返回的原因为未知，可能程序执行异常导致的
|
||||
* 0 异常计算
|
||||
* 1 正常计算
|
||||
*/
|
||||
private Integer causeFlag = 1;
|
||||
|
||||
/**
|
||||
* 暂降类型
|
||||
*/
|
||||
private Integer type;
|
||||
|
||||
/**
|
||||
* 可能分析失败，虽然返回的原因为未知，可能程序执行异常导致的
|
||||
* 0 异常计算
|
||||
* 1 正常计算
|
||||
*/
|
||||
private Integer typeFlag = 1;
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package com.njcn.advance.event.service;
|
||||
|
||||
import com.njcn.advance.event.pojo.EventAnalysisDTO;
|
||||
|
||||
/**
|
||||
* @author hongawen
|
||||
* @version 1.0
|
||||
* @data 2025/7/30 10:50
|
||||
*/
|
||||
public interface IEventAdvanceService {
|
||||
/**
|
||||
* 根据暂态信息获取暂降事件原因和类型
|
||||
* @param eventAnalysis 包含了暂降事件ID和波形名称
|
||||
* @return 分析后的结果
|
||||
*/
|
||||
EventAnalysisDTO analysisCauseAndType(EventAnalysisDTO eventAnalysis);
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
package com.njcn.advance.event.service;
|
||||
|
||||
import com.njcn.advance.event.cause.core.VoltageSagAnalyzer;
|
||||
import com.njcn.advance.event.cause.model.AnalysisResult;
|
||||
import com.njcn.advance.event.cause.model.DataFeature;
|
||||
import com.njcn.advance.event.cause.model.QvvrDataStruct;
|
||||
import com.njcn.advance.event.pojo.EventAnalysisDTO;
|
||||
import com.njcn.advance.event.type.jna.QvvrDLL;
|
||||
import com.njcn.common.pojo.exception.BusinessException;
|
||||
import com.njcn.event.file.component.WaveFileComponent;
|
||||
import com.njcn.event.file.pojo.dto.WaveDataDTO;
|
||||
import com.njcn.event.file.pojo.enums.WaveFileResponseEnum;
|
||||
import com.njcn.oss.constant.GeneralConstant;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.InputStream;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* @author hongawen
|
||||
* @version 1.0
|
||||
* @data 2025/7/30 11:24
|
||||
*/
|
||||
@Slf4j
|
||||
public class Test {
|
||||
|
||||
public static void main(String[] args) {
|
||||
WaveFileComponent waveFileComponent = new WaveFileComponent();
|
||||
EventAnalysisDTO eventAnalysis = new EventAnalysisDTO();
|
||||
WaveDataDTO waveDataDTO;
|
||||
String waveName = "5";
|
||||
String cfgPath, datPath;
|
||||
cfgPath = "D:\\comtrade\\00-B7-8D-00-FA-44" + File.separator + waveName + GeneralConstant.CFG;
|
||||
datPath = "D:\\comtrade\\00-B7-8D-00-FA-44" + File.separator + waveName + GeneralConstant.DAT;
|
||||
log.info("本地磁盘波形文件路径----" + cfgPath);
|
||||
InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath(cfgPath);
|
||||
InputStream datStream = waveFileComponent.getFileInputStreamByFilePath(datPath);
|
||||
if (Objects.isNull(cfgStream) || Objects.isNull(datStream)) {
|
||||
throw new BusinessException(WaveFileResponseEnum.ANALYSE_WAVE_NOT_FOUND);
|
||||
}
|
||||
waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 0);
|
||||
|
||||
|
||||
QvvrDataStruct qvvrDataStruct = new QvvrDataStruct();
|
||||
// 采样率
|
||||
qvvrDataStruct.setSmpRate(waveDataDTO.getComtradeCfgDTO().getFinalSampleRate());
|
||||
// 瞬时值
|
||||
List<List<Float>> listWaveData = waveDataDTO.getListWaveData();
|
||||
// 通道采样个数
|
||||
qvvrDataStruct.setSmpLen(listWaveData.size());
|
||||
// 获取ABC三相的瞬时数据
|
||||
// A相电压采样数据
|
||||
float[] smpVa = new float[listWaveData.size()];
|
||||
// B相电压采样数据
|
||||
float[] smpVb = new float[listWaveData.size()];
|
||||
// C相电压采样数据
|
||||
float[] smpVc = new float[listWaveData.size()];
|
||||
for (int i = 0; i < listWaveData.size(); i++) {
|
||||
smpVa[i] = listWaveData.get(i).get(1);
|
||||
smpVb[i] = listWaveData.get(i).get(2);
|
||||
smpVc[i] = listWaveData.get(i).get(3);
|
||||
}
|
||||
qvvrDataStruct.setSmpVa(smpVa);
|
||||
qvvrDataStruct.setSmpVb(smpVb);
|
||||
qvvrDataStruct.setSmpVc(smpVc);
|
||||
VoltageSagAnalyzer voltageSagAnalyzer = new VoltageSagAnalyzer();
|
||||
AnalysisResult cause = voltageSagAnalyzer.analyzeVoltageSagWithDetails(qvvrDataStruct);
|
||||
log.info("DAT文件分析结果: 原因={} ({})", cause.getCause(), getCauseDescription(cause.getCause()));
|
||||
|
||||
// 创建数据结构
|
||||
com.njcn.advance.event.type.jna.QvvrDLL.QvvrDataStruct typeDataStruct = new com.njcn.advance.event.type.jna.QvvrDLL.QvvrDataStruct();
|
||||
typeDataStruct.smp_rate = waveDataDTO.getComtradeCfgDTO().getFinalSampleRate();
|
||||
typeDataStruct.smp_len = listWaveData.size();
|
||||
// 获取ABC三相的瞬时数据
|
||||
for (int i = 0; i < listWaveData.size(); i++) {
|
||||
typeDataStruct.smp_va[i] = listWaveData.get(i).get(1);
|
||||
typeDataStruct.smp_vb[i] = listWaveData.get(i).get(2);
|
||||
typeDataStruct.smp_vc[i] = listWaveData.get(i).get(3);
|
||||
}
|
||||
// 执行算法分析 - 直接调用C DLL
|
||||
try {
|
||||
QvvrDLL.INSTANCE.qvvr_fun(typeDataStruct);
|
||||
if (typeDataStruct.evt_num > 0) {
|
||||
// 显示结果
|
||||
System.out.println("检测到事件数: " + typeDataStruct.evt_num);
|
||||
// 全局比较找出最小三相电压特征值
|
||||
float globalMinVoltage = Float.MAX_VALUE;
|
||||
int globalFaultType = -1;
|
||||
for (int i = 0; i < typeDataStruct.evt_num; i++) {
|
||||
QvvrDLL.EventBuffer evt = typeDataStruct.evt_buf[i];
|
||||
for (int j = 0; j < evt.u_min_num; j++) {
|
||||
float u3min = evt.u3_min[j];
|
||||
if (u3min < globalMinVoltage) {
|
||||
globalMinVoltage = u3min;
|
||||
globalFaultType = evt.qvvr_cata_type[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
System.out.println("=== 全局比较结果 ===");
|
||||
System.out.println("全局最小三相电压: " + String.format("%.3f", globalMinVoltage) + "V");
|
||||
System.out.println("最终暂降类型: " + globalFaultType + " (" + getFaultTypeDescription(globalFaultType) + ")");
|
||||
} else {
|
||||
System.out.println("结果: 未检测到电压暂降事件");
|
||||
}
|
||||
|
||||
} catch (Exception e) {
|
||||
System.err.println("调用DLL失败: " + e.getMessage());
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 获取原因描述
|
||||
*/
|
||||
private static String getCauseDescription(int cause) {
|
||||
switch (cause) {
|
||||
case DataFeature.CAUSE_TYPE0:
|
||||
return "未知原因";
|
||||
case DataFeature.CAUSE_TYPE1:
|
||||
return "短路故障";
|
||||
case DataFeature.CAUSE_TYPE2:
|
||||
return "电压调节器";
|
||||
case DataFeature.CAUSE_TYPE3:
|
||||
return "感应电机启动";
|
||||
case DataFeature.CAUSE_TYPE4:
|
||||
return "电压跌落";
|
||||
default:
|
||||
return "未定义原因";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 相数类型描述
|
||||
*/
|
||||
public static String getPhaseTypeDescription(int phaseType) {
|
||||
switch (phaseType) {
|
||||
case 1:
|
||||
return "单相";
|
||||
case 2:
|
||||
return "两相";
|
||||
case 3:
|
||||
return "三相";
|
||||
default:
|
||||
return "未知相数(" + phaseType + ")";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 故障类型描述
|
||||
*/
|
||||
public static String getFaultTypeDescription(int faultType) {
|
||||
switch (faultType) {
|
||||
case 0:
|
||||
return "BC相间故障";
|
||||
case 1:
|
||||
return "C相接地故障";
|
||||
case 2:
|
||||
return "AC相间故障";
|
||||
case 3:
|
||||
return "A相接地故障";
|
||||
case 4:
|
||||
return "AB相间故障";
|
||||
case 5:
|
||||
return "B相接地故障";
|
||||
case 6:
|
||||
return "BC相间接地";
|
||||
case 7:
|
||||
return "AC相间接地";
|
||||
case 8:
|
||||
return "AB相间接地";
|
||||
case 9:
|
||||
return "三相故障";
|
||||
case 10:
|
||||
return "未知";
|
||||
default:
|
||||
return "未知类型(" + faultType + ")";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package com.njcn.advance.event.service.impl;
|
||||
|
||||
import cn.hutool.core.util.StrUtil;
|
||||
import com.njcn.advance.event.cause.core.VoltageSagAnalyzer;
|
||||
import com.njcn.advance.event.cause.model.AnalysisResult;
|
||||
import com.njcn.advance.event.cause.model.DataFeature;
|
||||
import com.njcn.advance.event.cause.model.QvvrDataStruct;
|
||||
import com.njcn.advance.event.pojo.EventAnalysisDTO;
|
||||
import com.njcn.advance.event.service.IEventAdvanceService;
|
||||
import com.njcn.advance.event.type.jna.QvvrDLL;
|
||||
import com.njcn.common.config.GeneralInfo;
|
||||
import com.njcn.common.pojo.exception.BusinessException;
|
||||
import com.njcn.event.file.component.WaveFileComponent;
|
||||
import com.njcn.event.file.pojo.dto.WaveDataDTO;
|
||||
import com.njcn.event.file.pojo.enums.WaveFileResponseEnum;
|
||||
import com.njcn.oss.constant.GeneralConstant;
|
||||
import com.njcn.oss.constant.OssPath;
|
||||
import com.njcn.oss.utils.FileStorageUtil;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.stereotype.Service;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.InputStream;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* @author hongawen
|
||||
* @version 1.0
|
||||
* @data 2025/7/30 10:51
|
||||
*/
|
||||
@Slf4j
|
||||
@Service
|
||||
@RequiredArgsConstructor
|
||||
public class EventAdvanceServiceImpl implements IEventAdvanceService {
|
||||
|
||||
private final GeneralInfo generalInfo;
|
||||
|
||||
private final WaveFileComponent waveFileComponent;
|
||||
|
||||
private final FileStorageUtil fileStorageUtil;
|
||||
|
||||
|
||||
@Override
|
||||
public EventAnalysisDTO analysisCauseAndType(EventAnalysisDTO eventAnalysis) {
|
||||
WaveDataDTO waveDataDTO;
|
||||
String waveName = eventAnalysis.getWaveName();
|
||||
String cfgPath, datPath, cfgPath2, datPath2;
|
||||
String ip = eventAnalysis.getIp();
|
||||
if (generalInfo.getBusinessWaveFileStorage() == GeneralConstant.LOCAL_DISK) {
|
||||
cfgPath = generalInfo.getBusinessWavePath() + File.separator + ip + File.separator + waveName + GeneralConstant.CFG;
|
||||
datPath = generalInfo.getBusinessWavePath() + File.separator + ip + File.separator + waveName + GeneralConstant.DAT;
|
||||
log.info("本地磁盘波形文件路径----" + cfgPath);
|
||||
InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath(cfgPath);
|
||||
InputStream datStream = waveFileComponent.getFileInputStreamByFilePath(datPath);
|
||||
if (Objects.isNull(cfgStream) || Objects.isNull(datStream)) {
|
||||
throw new BusinessException(WaveFileResponseEnum.ANALYSE_WAVE_NOT_FOUND);
|
||||
}
|
||||
waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 0);
|
||||
} else {
|
||||
cfgPath = OssPath.WAVE_DIR + ip + StrUtil.SLASH + waveName + GeneralConstant.CFG;
|
||||
datPath = OssPath.WAVE_DIR + ip + StrUtil.SLASH + waveName + GeneralConstant.DAT;
|
||||
//适配文件后缀小写
|
||||
cfgPath2 = OssPath.WAVE_DIR + ip + StrUtil.SLASH + waveName + GeneralConstant.CFG.toLowerCase();
|
||||
datPath2 = OssPath.WAVE_DIR + ip + StrUtil.SLASH + waveName + GeneralConstant.DAT.toLowerCase();
|
||||
log.info("文件服务器波形文件路径----" + cfgPath);
|
||||
try (
|
||||
InputStream cfgStream = fileStorageUtil.getFileStream(cfgPath);
|
||||
InputStream datStream = fileStorageUtil.getFileStream(datPath)
|
||||
) {
|
||||
if (Objects.isNull(cfgStream) || Objects.isNull(datStream)) {
|
||||
throw new BusinessException(WaveFileResponseEnum.ANALYSE_WAVE_NOT_FOUND);
|
||||
}
|
||||
waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 0);
|
||||
} catch (Exception e) {
|
||||
try {
|
||||
InputStream cfgStream = fileStorageUtil.getFileStream(cfgPath2);
|
||||
InputStream datStream = fileStorageUtil.getFileStream(datPath2);
|
||||
if (Objects.isNull(cfgStream) || Objects.isNull(datStream)) {
|
||||
throw new BusinessException(WaveFileResponseEnum.ANALYSE_WAVE_NOT_FOUND);
|
||||
}
|
||||
waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 0);
|
||||
} catch (Exception e1) {
|
||||
throw new BusinessException(WaveFileResponseEnum.WAVE_DATA_INVALID);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
QvvrDataStruct qvvrDataStruct = new QvvrDataStruct();
|
||||
// 采样率
|
||||
qvvrDataStruct.setSmpRate(waveDataDTO.getComtradeCfgDTO().getFinalSampleRate());
|
||||
// 瞬时值
|
||||
List<List<Float>> listWaveData = waveDataDTO.getListWaveData();
|
||||
// 通道采样个数
|
||||
qvvrDataStruct.setSmpLen(listWaveData.size());
|
||||
// 获取ABC三相的瞬时数据
|
||||
// A相电压采样数据
|
||||
float[] smpVa = new float[listWaveData.size()];
|
||||
// B相电压采样数据
|
||||
float[] smpVb = new float[listWaveData.size()];
|
||||
// C相电压采样数据
|
||||
float[] smpVc = new float[listWaveData.size()];
|
||||
for (int i = 0; i < listWaveData.size(); i++) {
|
||||
smpVa[i] = listWaveData.get(i).get(1);
|
||||
smpVb[i] = listWaveData.get(i).get(2);
|
||||
smpVc[i] = listWaveData.get(i).get(3);
|
||||
}
|
||||
qvvrDataStruct.setSmpVa(smpVa);
|
||||
qvvrDataStruct.setSmpVb(smpVb);
|
||||
qvvrDataStruct.setSmpVc(smpVc);
|
||||
|
||||
// 暂降原因
|
||||
VoltageSagAnalyzer voltageSagAnalyzer = new VoltageSagAnalyzer();
|
||||
try{
|
||||
AnalysisResult cause = voltageSagAnalyzer.analyzeVoltageSagWithDetails(qvvrDataStruct);
|
||||
eventAnalysis.setCause(cause.getCause());
|
||||
}catch (Exception e){
|
||||
log.error("DAT文件分析异常", e);
|
||||
eventAnalysis.setCause(DataFeature.CAUSE_TYPE0);
|
||||
eventAnalysis.setCauseFlag(0);
|
||||
}
|
||||
|
||||
// 暂降类型
|
||||
// 创建数据结构
|
||||
com.njcn.advance.event.type.jna.QvvrDLL.QvvrDataStruct typeDataStruct = new com.njcn.advance.event.type.jna.QvvrDLL.QvvrDataStruct();
|
||||
typeDataStruct.smp_rate = waveDataDTO.getComtradeCfgDTO().getFinalSampleRate();
|
||||
typeDataStruct.smp_len = listWaveData.size();
|
||||
// 获取ABC三相的瞬时数据
|
||||
for (int i = 0; i < listWaveData.size(); i++) {
|
||||
typeDataStruct.smp_va[i] = listWaveData.get(i).get(1);
|
||||
typeDataStruct.smp_vb[i] = listWaveData.get(i).get(2);
|
||||
typeDataStruct.smp_vc[i] = listWaveData.get(i).get(3);
|
||||
}
|
||||
// 执行算法分析 - 直接调用C DLL
|
||||
try {
|
||||
QvvrDLL.INSTANCE.qvvr_fun(typeDataStruct);
|
||||
if (typeDataStruct.evt_num > 0) {
|
||||
// 全局比较找出最小三相电压特征值
|
||||
float globalMinVoltage = Float.MAX_VALUE;
|
||||
int globalFaultType = 10;
|
||||
for (int i = 0; i < typeDataStruct.evt_num; i++) {
|
||||
QvvrDLL.EventBuffer evt = typeDataStruct.evt_buf[i];
|
||||
for (int j = 0; j < evt.u_min_num; j++) {
|
||||
float u3min = evt.u3_min[j];
|
||||
if (u3min < globalMinVoltage) {
|
||||
globalMinVoltage = u3min;
|
||||
globalFaultType = evt.qvvr_cata_type[j];
|
||||
}
|
||||
}
|
||||
}
|
||||
eventAnalysis.setType(globalFaultType);
|
||||
} else {
|
||||
eventAnalysis.setType(DataFeature.TYPE10);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
eventAnalysis.setType(DataFeature.TYPE10);
|
||||
eventAnalysis.setTypeFlag(0);
|
||||
e.printStackTrace();
|
||||
}
|
||||
return eventAnalysis;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
package com.njcn.advance.event.type.jna;
|
||||
|
||||
import com.sun.jna.Library;
|
||||
import com.sun.jna.Native;
|
||||
import com.sun.jna.Structure;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* JNA接口调用qvvr_dll.dll
|
||||
*/
|
||||
public interface QvvrDLL extends Library {
|
||||
|
||||
/**
|
||||
* 加载DLL - 从resource目录或classpath
|
||||
*/
|
||||
QvvrDLL INSTANCE = loadLibrary();
|
||||
|
||||
/**
|
||||
* 支持jar打包的库加载方法 - 从jar内resources提取到临时目录后加载
|
||||
*/
|
||||
static QvvrDLL loadLibrary() {
|
||||
String osName = System.getProperty("os.name").toLowerCase();
|
||||
String libFileName;
|
||||
String resourcePath;
|
||||
|
||||
// 根据操作系统确定库文件名
|
||||
if (osName.contains("windows")) {
|
||||
libFileName = "qvvr_dll.dll";
|
||||
resourcePath = "/qvvr_dll.dll";
|
||||
} else if (osName.contains("linux")) {
|
||||
libFileName = "libqvvr.so";
|
||||
resourcePath = "/libqvvr.so";
|
||||
} else if (osName.contains("mac")) {
|
||||
libFileName = "libqvvr.dylib";
|
||||
resourcePath = "/libqvvr.dylib";
|
||||
} else {
|
||||
throw new UnsupportedOperationException("不支持的操作系统: " + osName);
|
||||
}
|
||||
|
||||
try {
|
||||
// 从jar中提取库文件到临时目录
|
||||
File tempLibFile = extractLibraryFromJar(resourcePath, libFileName);
|
||||
// 加载提取的库文件
|
||||
System.out.println("加载库文件: " + tempLibFile.getAbsolutePath());
|
||||
return Native.load(tempLibFile.getAbsolutePath(), QvvrDLL.class);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(
|
||||
"无法加载QVVR库文件。\n" +
|
||||
"请确保文件 " + libFileName + " 存在于 src/main/resources/ 目录下。\n" +
|
||||
"当前操作系统: " + osName,
|
||||
e
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 从jar中提取库文件到临时目录
|
||||
*/
|
||||
static File extractLibraryFromJar(String resourcePath, String libFileName) throws IOException {
|
||||
// 获取资源输入流
|
||||
InputStream libStream = QvvrDLL.class.getResourceAsStream(resourcePath);
|
||||
if (libStream == null) {
|
||||
throw new FileNotFoundException("在jar中找不到库文件: " + resourcePath);
|
||||
}
|
||||
|
||||
// 创建临时文件
|
||||
String tempDir = System.getProperty("java.io.tmpdir");
|
||||
File tempLibFile = new File(tempDir, "qvvr_" + System.currentTimeMillis() + "_" + libFileName);
|
||||
|
||||
// 提取库文件到临时目录
|
||||
try (FileOutputStream out = new FileOutputStream(tempLibFile)) {
|
||||
byte[] buffer = new byte[8192];
|
||||
int bytesRead;
|
||||
while ((bytesRead = libStream.read(buffer)) != -1) {
|
||||
out.write(buffer, 0, bytesRead);
|
||||
}
|
||||
} finally {
|
||||
libStream.close();
|
||||
}
|
||||
|
||||
// 设置为可执行
|
||||
tempLibFile.setExecutable(true);
|
||||
tempLibFile.setReadable(true);
|
||||
|
||||
// JVM退出时删除临时文件
|
||||
tempLibFile.deleteOnExit();
|
||||
|
||||
System.out.println("已提取库文件到: " + tempLibFile.getAbsolutePath());
|
||||
return tempLibFile;
|
||||
}
|
||||
|
||||
/**
|
||||
* 直接调用C DLL的qvvr_fun函数
|
||||
* void __stdcall qvvr_fun(void *data)
|
||||
*/
|
||||
void qvvr_fun(QvvrDataStruct data);
|
||||
|
||||
/**
|
||||
* 对应C语言的qvvr_data_struct结构体
|
||||
*/
|
||||
public static class QvvrDataStruct extends Structure {
|
||||
|
||||
// 输入数据
|
||||
public float[] smp_va = new float[128 * 50 * 120]; // A相电压
|
||||
public float[] smp_vb = new float[128 * 50 * 120]; // B相电压
|
||||
public float[] smp_vc = new float[128 * 50 * 120]; // C相电压
|
||||
public int smp_rate; // 采样频率
|
||||
public int smp_len; // 数据长度
|
||||
|
||||
// 输出结果
|
||||
public int evt_num; // 事件数量
|
||||
public EventBuffer[] evt_buf = new EventBuffer[32]; // 事件缓冲区
|
||||
|
||||
@Override
|
||||
protected List<String> getFieldOrder() {
|
||||
return Arrays.asList("smp_va", "smp_vb", "smp_vc", "smp_rate", "smp_len", "evt_num", "evt_buf");
|
||||
}
|
||||
|
||||
public QvvrDataStruct() {
|
||||
super();
|
||||
// 初始化事件缓冲区
|
||||
for (int i = 0; i < 32; i++) {
|
||||
evt_buf[i] = new EventBuffer();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 事件缓冲区结构
|
||||
*/
|
||||
public static class EventBuffer extends Structure {
|
||||
public int[] qvvr_cata_cause = new int[256];
|
||||
public int[] qvvr_phasetype = new int[256];
|
||||
public int[] qvvr_cata_type = new int[256];
|
||||
|
||||
public float hold_time_rms;
|
||||
public float hold_time_dq;
|
||||
|
||||
public float POW_a;
|
||||
public float POW_b;
|
||||
public float POW_c;
|
||||
|
||||
public float Voltagechange_Va;
|
||||
public float Voltagechange_Vb;
|
||||
public float Voltagechange_Vc;
|
||||
|
||||
public int SEG_T_num;
|
||||
public int[] SEG_T0_idx = new int[256];
|
||||
public int[] SEG_T_idx = new int[256];
|
||||
|
||||
public int SEG_RMS_T_num;
|
||||
public int[] SEG_RMS_T_idx = new int[256];
|
||||
|
||||
public int u_min_num;
|
||||
public float[] ua_min = new float[256];
|
||||
public float[] ub_min = new float[256];
|
||||
public float[] uc_min = new float[256];
|
||||
public float[] u3_min = new float[256];
|
||||
public int[] order_min_idx = new int[256];
|
||||
|
||||
public float[] angle_diff_ap = new float[256];
|
||||
public float[] angle_diff_bp = new float[256];
|
||||
public float[] angle_diff_cp = new float[256];
|
||||
public float[] angle_diff_an = new float[256];
|
||||
public float[] angle_diff_bn = new float[256];
|
||||
public float[] angle_diff_cn = new float[256];
|
||||
|
||||
public float[] bph_max_value = new float[256];
|
||||
|
||||
@Override
|
||||
protected List<String> getFieldOrder() {
|
||||
return Arrays.asList(
|
||||
"qvvr_cata_cause", "qvvr_phasetype", "qvvr_cata_type",
|
||||
"hold_time_rms", "hold_time_dq",
|
||||
"POW_a", "POW_b", "POW_c",
|
||||
"Voltagechange_Va", "Voltagechange_Vb", "Voltagechange_Vc",
|
||||
"SEG_T_num", "SEG_T0_idx", "SEG_T_idx",
|
||||
"SEG_RMS_T_num", "SEG_RMS_T_idx",
|
||||
"u_min_num", "ua_min", "ub_min", "uc_min", "u3_min", "order_min_idx",
|
||||
"angle_diff_ap", "angle_diff_bp", "angle_diff_cp",
|
||||
"angle_diff_an", "angle_diff_bn", "angle_diff_cn",
|
||||
"bph_max_value"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -408,7 +408,15 @@ public class WaveFileComponent {
|
||||
}
|
||||
|
||||
//WW 2019-11-14 // 采样频率
|
||||
int nFreq = Integer.parseInt(bufferedReader.readLine());
|
||||
String freqLine = bufferedReader.readLine();
|
||||
int nFreq;
|
||||
try {
|
||||
// 先尝试解析为double再四舍五入为整数，以兼容"50.00"这样的格式
|
||||
nFreq = (int) Math.round(Double.parseDouble(freqLine));
|
||||
} catch (NumberFormatException e) {
|
||||
// 如果失败则使用原来的整数解析方式
|
||||
nFreq = Integer.parseInt(freqLine);
|
||||
}
|
||||
|
||||
// 获取采样段数
|
||||
strFileLine = bufferedReader.readLine();
|
||||
@@ -670,6 +678,8 @@ public class WaveFileComponent {
|
||||
nFinalOneSample = 32;
|
||||
} else if (nMinOneSample > 128) {
|
||||
nFinalOneSample = 128;
|
||||
}else {
|
||||
nFinalOneSample = nMinOneSample;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
@@ -1225,10 +1235,10 @@ public class WaveFileComponent {
|
||||
s = sdf.format(d);
|
||||
System.out.println(s);
|
||||
WaveFileComponent waveFileComponent = new WaveFileComponent();
|
||||
InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath("D:\\comtrade\\00-B7-8D-00-B7-25\\1_20200629_164016_234.CFG");
|
||||
InputStream datStream = waveFileComponent.getFileInputStreamByFilePath("D:\\comtrade\\00-B7-8D-00-B7-25\\1_20200629_164016_234.DAT");
|
||||
InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath("D:\\comtrade\\00-B7-8D-00-FA-44\\PQMonitor_PQM1_005_20250709_173908_812.CFG");
|
||||
InputStream datStream = waveFileComponent.getFileInputStreamByFilePath("D:\\comtrade\\00-B7-8D-00-FA-44\\PQMonitor_PQM1_005_20250709_173908_812.DAT");
|
||||
// 获取瞬时波形 //获取原始波形值
|
||||
WaveDataDTO waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 1);
|
||||
WaveDataDTO waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 0);
|
||||
d = new Date();
|
||||
s = sdf.format(d);
|
||||
System.out.println(s);
|
||||
|
||||
Reference in New Issue
Block a user