calculate.h

故障测距软件编程

#include <math.h>
#include <stdio.h>



#define pi 3.1415926


//********************************************************
//结构体定义
//********************************************************
//========================================================
//定义复数的结构体
//========================================================
//复数定义
struct complex{
	double real_part	 ;  //实部
	double img_part ;  //虚部
	double amp ;  //幅值
	double deg ;  //角度(rad)
};

//端点参数
struct fault_data{
	complex ua,ub,uc;
	complex ia,ib,ic;
	int sample_point ;
};
//========================================================






//========================================================
//定义复数3*1列向量的结构体
//========================================================
struct complex_lie
{
        struct complex m11 ;
        struct complex m21 ;
        struct complex m31 ;
};
//========================================================






//========================================================
//定义复数二阶矩阵的结构体
//========================================================
struct complex_matrix2
{
	struct complex m11 ;
	struct complex m12 ;

	struct complex m21 ;
	struct complex m22 ;
};
//========================================================






//========================================================
//定义复数三阶矩阵的结构体
//========================================================
struct complex_matrix3
{
	struct complex m11 ;
	struct complex m12 ;
	struct complex m13 ;

	struct complex m21 ;
    struct complex m22 ;
	struct complex m23 ;

    struct complex m31 ;
    struct complex m32 ;
	struct complex m33 ;
};
//========================================================


//故障录波参数定义
double Ua_head[300] ;
double Ub_head[300] ;
double Uc_head[300] ;
double Ia_head[300] ;
double Ib_head[300] ;
double Ic_head[300] ;
int flag_fault_head = NON_READ ;

double Ua_end[300] ;
double Ub_end[300] ;
double Uc_end[300] ;
double Ia_end[300] ;
double Ib_end[300] ;
double Ic_end[300] ;
int flag_fault_end = NON_READ ;


struct fault_data head_data,end_data ;

//线路二次计算参数定义
//首端高抗
struct complex XL_head ;   //Ω
struct complex Xn_head ;   //Ω
struct complex x1_head ; 
struct complex x0_head ;
struct complex y1_head ;
struct complex y0_head ;

//末端高抗
struct complex XL_end ;   //Ω
struct complex Xn_end ;   //Ω
struct complex x1_end ; 
struct complex x0_end ;
struct complex y1_end ;
struct complex y0_end ;


//串联补偿
struct complex Xc ;






//========================================================
//极坐标与直角坐标的转换
//========================================================
struct complex ji_to_zhijiao(double X,double angle)
{
       struct complex result ;
       result.real_part = X*cos(angle) ;
       result.img_part = X*sin(angle) ;
       return result ;
}
//========================================================



//========================================================
//直角坐标与极坐标的转换
//========================================================
struct complex zhijiao_to_ji(struct complex x)
{
       struct complex result ;
	   result.amp = sqrt(x.real_part*x.real_part+x.img_part*x.img_part) ;
	   result.deg = atan(x.img_part/x.real_part) ;
       return result ;

}
//========================================================



//========================================================
//复数幅值
//========================================================
double complex_abs(struct complex x)
{
	double result ;
	result = sqrt(x.real_part*x.real_part+x.img_part*x.img_part) ;
	return result ;
}
//========================================================



//========================================================
//复数乘法
//========================================================
 
struct complex complex_multi(struct complex a,struct complex b)
{
	struct complex result ;

	result.real_part = a.real_part*b.real_part-a.img_part*b.img_part ;
	result.img_part = a.real_part*b.img_part+a.img_part*b.real_part ;

	return result ;
}
//========================================================





//========================================================
//复数除法
//========================================================
struct complex complex_divid(struct complex x,struct complex y)
{
	struct complex result ;

	result.real_part = (x.real_part*y.real_part+x.img_part*y.img_part)/(y.real_part*y.real_part+y.img_part*y.img_part) ;
	result.img_part = (x.img_part*y.real_part-x.real_part*y.img_part)/(y.real_part*y.real_part+y.img_part*y.img_part) ;

	return result ;
}
//========================================================





//========================================================
//复数加法
//========================================================
struct complex complex_plus(struct complex x,struct complex y)
{
		struct complex result ;
		result.real_part = x.real_part+y.real_part ;
		result.img_part = x.img_part+y.img_part ;
		return result ;
}
//========================================================





//========================================================
//复数减法
//========================================================
struct complex complex_sub(struct complex x,struct complex y)
{
		struct complex result ;
		result.real_part = x.real_part-y.real_part ;
		result.img_part = x.img_part-y.img_part ;
		return result ;

}
//========================================================


//========================================================
//复数开方
//========================================================
struct complex complex_sqrt(struct complex x)
{
		struct complex result ;
		x.amp = sqrt(x.real_part*x.real_part+x.img_part*x.img_part) ;
		result.amp = sqrt(x.amp) ;
		result.deg = atan(x.img_part/x.real_part)/2 ;
		result.real_part = result.amp*cos(result.deg) ;
		result.img_part = result.amp*sin(result.deg) ;
		return result ;

}
//========================================================





//========================================================
//复数指数运算(可考虑不要)
//========================================================
struct complex complex_exp(struct complex x)
{
	struct complex result ;
	result.real_part = exp(x.real_part)*cos(x.img_part) ;
	result.img_part = exp(x.real_part)*sin(x.img_part) ;
	return result ;

}
//========================================================





//========================================================
//复数双曲余弦函数
//========================================================
struct complex cosh_complex(struct complex x)
{
       struct complex result ;
       result.real_part = (exp(x.real_part)+exp(-x.real_part))*cos(x.img_part)*0.5 ;
       result.img_part = (exp(x.real_part)-exp(-x.real_part))*sin(x.img_part)*0.5 ;
       return result ;

}
//========================================================





//========================================================
//复数双曲正弦函数
//========================================================
struct complex sinh_complex(struct complex x)
{
       struct complex result ;
       result.real_part = (exp(x.real_part)-exp(-x.real_part))*cos(x.img_part)*0.5 ;
       result.img_part = (exp(x.real_part)+exp(-x.real_part))*sin(x.img_part)*0.5 ;
       return result ;
}
//========================================================






//========================================================
//常数乘以一个复数
//========================================================
struct complex constant_multi_complex(double a,struct complex b) 
{
	struct complex result ;
	result.real_part = a*b.real_part ;
	result.img_part = a*b.img_part ;
	return result ;
}
//========================================================






//========================================================
//二阶复数矩阵相乘
//========================================================
struct complex_matrix2 matrix2_multi(struct complex_matrix2 a,struct complex_matrix2 b)
{
       struct complex_matrix2 result ;
       result.m11 = complex_plus(complex_multi(a.m11,b.m11),complex_multi(a.m12,b.m21)) ;
       result.m12 = complex_plus(complex_multi(a.m11,b.m12),complex_multi(a.m12,b.m22)) ;

       result.m21 = complex_plus(complex_multi(a.m21,b.m11),complex_multi(a.m22,b.m21)) ;
       result.m22 = complex_plus(complex_multi(a.m21,b.m12),complex_multi(a.m22,b.m22)) ;  
       return result ;
} 
//========================================================






//========================================================
//三阶复数矩阵相乘
//========================================================
struct complex_matrix3 matrix3_multi(struct complex_matrix3 a,struct complex_matrix3 b)
{
       struct complex_matrix3 result ;
       result.m11 = complex_plus(complex_plus(complex_multi(a.m11,b.m11),complex_multi(a.m12,b.m21)),complex_multi(a.m13,b.m31)) ;
       result.m12 = complex_plus(complex_plus(complex_multi(a.m11,b.m12),complex_multi(a.m12,b.m22)),complex_multi(a.m13,b.m32)) ;
       result.m13 = complex_plus(complex_plus(complex_multi(a.m11,b.m13),complex_multi(a.m12,b.m23)),complex_multi(a.m13,b.m33)) ;

       result.m21 = complex_plus(complex_plus(complex_multi(a.m21,b.m11),complex_multi(a.m22,b.m21)),complex_multi(a.m23,b.m31)) ;
       result.m22 = complex_plus(complex_plus(complex_multi(a.m21,b.m12),complex_multi(a.m22,b.m22)),complex_multi(a.m23,b.m32)) ;
       result.m23 = complex_plus(complex_plus(complex_multi(a.m21,b.m13),complex_multi(a.m22,b.m23)),complex_multi(a.m23,b.m33)) ;

       result.m31 = complex_plus(complex_plus(complex_multi(a.m31,b.m11),complex_multi(a.m32,b.m21)),complex_multi(a.m33,b.m31)) ;
       result.m32 = complex_plus(complex_plus(complex_multi(a.m31,b.m12),complex_multi(a.m32,b.m22)),complex_multi(a.m33,b.m32)) ;
       result.m33 = complex_plus(complex_plus(complex_multi(a.m31,b.m13),complex_multi(a.m32,b.m23)),complex_multi(a.m33,b.m33)) ;
       return result ;
} 
//========================================================







//========================================================
//三阶复数矩阵乘以列向量
//========================================================
struct complex_lie matrix_multi_lie(struct complex_matrix3 A,struct complex_lie a)
{
       struct complex_lie result ;
       struct complex temp,temp1 ;
       temp = complex_multi(A.m21,a.m11) ;
       temp1 = complex_multi(A.m22,a.m21) ;
       temp = complex_plus(temp,temp1) ;
       result.m11 = complex_plus(complex_plus(complex_multi(A.m11,a.m11),complex_multi(A.m12,a.m21)),complex_multi(A.m13,a.m31)) ;
       result.m21 = complex_plus(complex_plus(complex_multi(A.m21,a.m11),complex_multi(A.m22,a.m21)),complex_multi(A.m23,a.m31)) ;
       result.m31 = complex_plus(complex_plus(complex_multi(A.m31,a.m11),complex_multi(A.m32,a.m21)),complex_multi(A.m33,a.m31)) ;
       return result ;
}
//========================================================




//========================================================
//FFT算法
//========================================================
struct complex FFT_ZY(double x[300], int sample)
{
	int i ;
	struct complex e[300] ;
	double t ;
	struct complex temp ;
	struct complex result,result_temp;
	temp.real_part = 0 ;
	temp.img_part = 1 ;

	result_temp.img_part = 0 ;
	result_temp.real_part  = 0 ;

	for(i=0;i<sample;i++)
	{
		t = 2*pi*i/sample ;
		e[i] = complex_exp(constant_multi_complex(t,temp)) ;
	}
	for(i=0;i<sample;i++)
	{
		t = x[i]*2/sample ;
		result = constant_multi_complex(t,e[i]) ;
		result_temp = complex_plus(result,result_temp) ;
	}

	//相的有效值和相位
	result.amp = complex_abs(result_temp)/sqrt(2) ;
	result.deg = atan(-result_temp.img_part/result_temp.real_part) ;

	return result ;
}



//========================================================




//========================================================
//线路相关参数计算
//========================================================