analysis.cpp

一个用C++写的电力系统故障录波数据管理系统

                else if(jj>0)jj--;
                }
        if(*(j2+i)&2)
                {pqc(vc,ic,&jc,i);/*printf(" jc=%i",jc);*/
                if(jc>0){
								jjj++;
								if(jjj>=3){np++;*tx=*tx|8;*nqc=i;break;}
                        }
                else if(jjj>0)jjj--;
                }
        }

if(i>=lon-7)*nqc=10000;
if(guzq[0])tra=1;
*tx=ja=jb=jc=0;
if((!tra)&&(*nqc<1000))
        {
        for(j=jj=jjj=0,k=*nqc;k<lon-10;k++)
                {if(!ja)
                        {
                        yx=youxz1(ia+k);if(yx<.05)j++;else if(j>0)j--;
                        if(j>3)ja++;
                        }
                if(!jb)
								{
								yx=youxz1(ib+k);if(yx<.05)jj++;else if(jj>0)jj--;
                        if(jj>3)jb++;
                        }
                if(!jc)
                        {
                        yx=youxz1(ic+k);if(yx<.05)jjj++;else if(jjj>0)jjj--;
                        if(jjj>3)jc++;
                        }
					 if(ja&&jb&&jc)break;
                }
        }
if(ja+jb+jc>1)ja=jb=jc=1;
if(ja)*tx=*tx|8;if(jb)*tx=*tx|4;if(jc)*tx=*tx|2;
if(tra)*tx=0;
return(1);
}



int CAnalysis::jlpqc1(int *nqd,int *nqc,int *tx,int tra)
{

int i,j,k,ja,jb,jc,jd,jj,jjj;
double yx;
j=jj=jjj=*nqc=*tx=0;
for(i=0;i<400;i++)*(j1+i)=*(j2+i)=0;
for(i=*nqd-2;i<lon-7;i++)
        {
/*      printf("\n%i ",i);*/
        px2(va,ia,&ja,i);
        px2(vb,ib,&jb,i);
        px2(vc,ic,&jc,i);
        px2(vd,i0,&jd,i);
        if(ja>0)*(j1+i)=*(j1+i)|8;
        if(jb>0)*(j1+i)=*(j1+i)|4;
        if(jc>0)*(j1+i)=*(j1+i)|2;
        if(jd>0)*(j1+i)=*(j1+i)|1;
/*      if((*(j1+i)!=1)&&(*(j1+i)!=2)&&(*(j1+i)!=4)&&(*(j1+i)!=8)&&*/
		  if((ja>0)&&(*(j1+i-1)&8==8)&&(*(j1+i-2)&8==8)&&(*(j1+i-3)&8==8))
                {
                *(j2+i)=(*(j2+i)|8)|*(j2+i-1);
                }
		  if((jb>0)&&(*(j1+i-1)&4==4)&&(*(j1+i-2)&4==4)&&(*(j1+i-3)&4==4))
					 {
                *(j2+i)=(*(j2+i)|4)|*(j2+i-1);
                }
		  if((jc>0)&&(*(j1+i-1)&2==2)&&(*(j1+i-2)&2==2)&&(*(j1+i-3)&2==2))
                {
                *(j2+i)=(*(j2+i)|2)|*(j2+i-1);
                }
		  if((jd>0)&&(*(j1+i-1)&1==1)&&(*(j1+i-2)&1==1)&&(*(j1+i-3)&1==1))
                {
					 *(j2+i)=(*(j2+i)|1)|*(j2+i-1);
                }
        *(j2+i)=*(j2+i)|*(j2+i-1);
        if(*(j2+i)&8)
                {pqc(va,ia,&ja,i);
                if(ja>0){
                        j++;
                        if(j>=3){np++;*tx=*tx|8;*nqc=i;break;}
                        }
                else if(j>0)j--;
                }
        if(*(j2+i)&4)
                {pqc(vb,ib,&jb,i);
                if(jb>0){
                        jj++;
                        if(jj>=3){np++;*tx=*tx|4;*nqc=i;break;}
                        }
                else if(jj>0)jj--;
					 }
		  if(*(j2+i)&2)
                {pqc(vc,ic,&jc,i);
                if(jc>0){
                        jjj++;
                        if(jjj>=3){np++;*tx=*tx|2;*nqc=i;break;}
                        }
                else if(jjj>0)jjj--;
                }
        }
if(i>=lon-7)*nqc=10000;
/*printf("nqc=%i lon=%i\n",*nqc,lon-7);getch(); */
if(guzq[0])tra=1;
*tx=ja=jb=jc=0;
if((!tra)&&(*nqc<1000))
        {
        for(j=jj=jjj=0,k=*nqc;k<lon-10;k++)
                {/*printf("\n%i ",k);*/
                if(!ja)
                        {
                        yx=youxz1(ia+k);if(yx<.05)j++;else if(j>0)j--;
                        if(j>3)ja++;/*printf("a=%f   ",yx);*/
                        }
                else if(!jb)
                        {
                        yx=youxz1(ib+k);if(yx<.05)jj++;else if(jj>0)jj--;
                        if(jj>3)jb++;/*printf("b=%f   ",yx);*/
                        }
					 else if(!jc)
								{
                        yx=youxz1(ic+k);if(yx<.05)jjj++;else if(jjj>0)jjj--;
                        if(jjj>3)jc++;/*printf("c=%f\n",yx);*/
                        }
                if(ja&&jb&&jc)break;
                }
        }
 if(ja+jb+jc>1)ja=jb=jc=1;
 if(ja)*tx=*tx|8;if(jb)*tx=*tx|4;if(jc)*tx=*tx|2;
 if(tra)*tx=0;
 return (1);
}





int CAnalysis::px(double *u,double *i,double *ii,double *iii,int *jj,int n,int m)
{
double z,x,r,d1,dd,d2,*in,*im,*un,in1,in2,in3,in4,in5,in6,im2,im5,un2,un5;
double *iin,*iiin,*iim,*iiim;
in=i+n;im=i+m;un=u+n;iin=ii+n;iiin=iii+n;iim=ii+m;iiim=iii+m;
*jj=0;
in1=*(in+1)+*(in+2);
in2=*(in+2)+*(in+3);
in3=*(in+3)+*(in+4);
in4=*(in+4)+*(in+5);
in5=*(in+5)+*(in+6);
in6=*(in+6)+*(in+7);
im2=*(im+2)+*(im+3);
im5=*(im+5)+*(im+6);
un2=*(un+2)+*(un+3);
un5=*(un+5)+*(un+6);
d1=fabs(*(in+1)-*(iin+1)-*(im+1)+*(iim+1))
  +fabs(*(in+2)-*(iin+2)-*(im+2)+*(iim+2))
  +fabs(*(in+3)-*(iin+3)-*(im+3)+*(iim+3))
  +fabs(*(in+4)-*(iin+4)-*(im+4)+*(iim+4))
  +fabs(*(in+5)-*(iin+5)-*(im+5)+*(iim+5))
  +fabs(*(in+6)-*(iin+6)-*(im+6)+*(iim+6))
  +fabs(*(in+7)-*(iin+7)-*(im+7)+*(iim+7));
d2=fabs(*(in+1)-*(iiin+1)-*(im+1)+*(iiim+1))
  +fabs(*(in+2)-*(iiin+2)-*(im+2)+*(iiim+2))
  +fabs(*(in+3)-*(iiin+3)-*(im+3)+*(iiim+3))
  +fabs(*(in+4)-*(iiin+4)-*(im+4)+*(iiim+4))
  +fabs(*(in+5)-*(iiin+5)-*(im+5)+*(iiim+5))
  +fabs(*(in+6)-*(iiin+6)-*(im+6)+*(iiim+6))
  +fabs(*(in+7)-*(iiin+7)-*(im+7)+*(iiim+7));
dd=fabs(*(iin+1)-*(iiin+1)-*(iim+1)+*(iiim+1))
  +fabs(*(iin+2)-*(iiin+2)-*(iim+2)+*(iiim+2))
  +fabs(*(iin+3)-*(iiin+3)-*(iim+3)+*(iiim+3))
  +fabs(*(iin+4)-*(iiin+4)-*(iim+4)+*(iiim+4))
  +fabs(*(iin+5)-*(iiin+5)-*(iim+5)+*(iiim+5))
  +fabs(*(iin+6)-*(iiin+6)-*(iim+6)+*(iiim+6))
  +fabs(*(iin+7)-*(iiin+7)-*(iim+7)+*(iiim+7));
/*printf("d1=%3.1f d2=%3.1f    ",dd/d1,dd/d2);*/
if((3.5*d1<dd)||(3.5*d2<dd))return(0);

d1=in2*r1/x1+(in3-in1)/dt;
d2=in5*r1/x1+(in6-in4)/dt;
dd=(in2-im2)*d2-(in5-im5)*d1;
if(fabs(dd)<.1)goto fz1;
x=(un5*(in2-im2)-un2*(in5-im5))/dd;
r=(d2*un2-d1*un5)/dd;
z=r*r+x*x;
if(z<12*zzd*zzd)*jj=1;
fz1:
d1=(in3-in1)/dt;
d2=(in6-in4)/dt;
dd=in2*d2-in5*d1;
if(fabs(dd)<.1)return(0);
x=(un5*in2-un2*in5)/dd;
r=(d2*un2-d1*un5)/dd;
z=r*r+x*x;
if(z<zzd*zzd)*jj=1;

return(0);
}


int CAnalysis::jl3(double *i1,int nqd1,double *x)
{
 int i,ret=0;
 double s1,s2,ifzq,tfzq;
 
 *x=0;*(x+1)=1;
 for(s1=s2=0,i=nqd1;i<nqd1+20;i++)
	{
	  s1+=*(i1+i);
	  s2+=*(i1+i+5);
	}
 if((fabs(s1)<10.0)||(s1/s2<1.0001)) return (ret);
 tfzq=.005/log(s1/s2);
 ifzq=s1/(1-exp(-.02/tfzq))/tfzq*.001;
 ret=1;
 *(x+1)=ifzq;
 *(x+0)=tfzq;
 return(ret);
}



void CAnalysis::lb1(double *u,double *v,int j)
{
  double *uj;
  uj=u+j;
  *v=.6768*(*(uj-5)+*(uj+5))+1.433*(*(uj-4)+*(uj+4))+2.233*(*(uj-3)+*(uj+3))+
  3.209*(*(uj-2)+*(uj+2))+3.783*(*(uj-1)+*(uj+1))+4.101**uj;
  *v=*v/19.9996567;
}

void CAnalysis::lb2(double *u,double *v,int j)
{
double *uj;
uj=u+j;
*v=.2839*(*(uj-4)+*(uj+4))+1.253*(*(uj-3)+*(uj+3))+
  2.87*(*(uj-2)+*(uj+2))+4.488*(*(uj-1)+*(uj+1))+5.172**uj;
*v=*v/20.0008907;
}


void CAnalysis::lb3(double *u,double *v,int j)
{
double *uj;
uj=u+j;
*v=.44*(*(uj-3)+*(uj+3))+1.361*(*(uj-2)+*(uj+2))+
  2.354*(*(uj-1)+*(uj+1))+2.799**uj;
*v=*v/9.9959698;
}


void CAnalysis::lb4(double *u,double *v,int j)
{
double *uj;
uj=u+j;
*v=0.975*(*(uj-2)+*(uj+2))+2.612*(*(uj-1)+*(uj+1))+3.435**uj;
*v=*v/9.9809027;
}


void CAnalysis::lb5(double *u,double *v,int j)
{
double *uj;
uj=u+j;
*v=0.02953*(*(uj-7)-*(uj+7))+.05954*(*(uj-6)-*(uj+6))+
0.10067*(*(uj-5)-*(uj+5))+.12861*(*(uj-4)-*(uj+4))+
0.13581*(*(uj-3)-*(uj+3))+.11339*(*(uj-2)-*(uj+2))+
.06468*(*(uj-1)-*(uj+1));
}


void CAnalysis::lb6(double *u,double *v,int j)
{
double *uj;
uj=u+j;
*v=*(uj-1)+*(uj+1)+1.5**uj;
*v=*v/3.402113;
}

void CAnalysis::lb7(double*u,double*v,int j)
{
double *uj;
uj=u+j;
*v=.5*(*(uj-10)+*(uj+10))+.951057*(*(uj-9)+*(uj+9))
+.809017*(*(uj-8)+*(uj+8))+.58778853*(*(uj-7)+*(uj+7))
+.309017*(*(uj-6)+*(uj+6))-.309017*(*(uj-4)+*(uj+4))
-.58778853*(*(uj-3)+*(uj+3))-.809017*(*(uj-2)+*(uj+2))
-.951057*(*(uj-1)+*(uj+1))-*(uj);
*v=.1**v;
}

void CAnalysis::lb8(double*u,double*v,int j)
{
 double *uj,f1;
 int i;
 for(f1=0,i=0;i<7;i++)
	{
	uj=u+j+i;
	f1 += .5 * (*(uj-10) + *(uj+10))   + .951057 *  (*(uj-9) + *(uj+9))
	      +.809017 * (*(uj-8)+*(uj+8)) + .58778853* (*(uj-7) + *(uj+7))
	      +.309017 * (*(uj-6)+*(uj+6)) - .309017  * (*(uj-4) + *(uj+4))
	      -.58778853*(*(uj-3)+*(uj+3)) - .809017  * (*(uj-2)+*(uj+2))
	      -.951057 * (*(uj-1)+*(uj+1)) - *(uj);
	}
 *v=.017557*f1;
}

int CAnalysis::jdjl(double *u,double *i,double *i0,double *im0,int k,double *x,double *r)
{
 
 double d1,d2,a1,a2,dd,s,*ik,*i0k,*im0k,*uk;
 ik=i+k;i0k=i0+k;im0k=im0+k;uk=u+k;


 *x=*(x-1);*r=*(r-1);
 d1=(*ik-*(ik-2)+kl*(*i0k-*(i0k-2))+kml*(*im0k-*(im0k-2)))/dt;
	 d2=(*(ik+2)-*ik+kl*(*(i0k+2)-*i0k)+kml*(*(im0k+2)-*im0k))/dt;
 a1=*(ik-1)+kr**(i0k-1)+kmr**(im0k-1);
 a2=*(ik+1)+kr**(i0k+1)+kmr**(im0k+1);;
 dd=a1*d2-a2*d1;

 if(fabs(dd)<.01)return (1);
 
 *x=(*(uk+1)*a1-(*(uk-1)*a2))/dd/x1;
 if((*x<100.)||(!c0)||(!c1))
  {
   *r=(*(uk-1)*d2-*(uk+1)*d1)/dd*nz;
   *r=*r-*x*r1*nz;
   return (1);
  }
 *x=atan(c1**x)/c1;
 s=atan(c0**x)/c0/atan(c1**x)*c1;
 d1=(*ik-*(ik-2)+s*kl*(*i0k-*(i0k-2))+kml*(*im0k-*(im0k-2)))/dt;
 d2=(*(ik+2)-*ik+s*kl*(*(i0k+2)-*i0k)+kml*(*(im0k+2)-*im0k))/dt;
 dd=a1*d2-a2*d1;
 if(fabs(dd)<.01)return (1);
 *x=(*(uk+1)*a1-(*(uk-1)*a2))/dd/x1;
 if(c1!=.0)*x=atan(*x*c1)/c1;
 *r=(*(uk-1)*d2-*(uk+1)*d1)/dd*nz;
 *r=*r-*x*r1*nz;
 return (1);

}


int CAnalysis::xjjl(double *u1,double *u2,double *i1,double *i2,int n,double *x,double *r)
{
  double d1,d2,a1,a2,dd;
  double *i1n,*i2n,*u1n,*u2n;
  i1n=i1+n;i2n=i2+n;u1n=u1+n;u2n=u2+n;
  *x=*(x-1);*r=*(r-1);
  
  d1=(*i1n-*(i1n-2)-*i2n+*(i2n-2))/dt;
  d2=(*(i1n+2)-*i1n-*(i2n+2)+*i2n)/dt;
  
  a1=*(i1n-1)-*(i2n-1);
  a2=*(i1n+1)-*(i2n+1);

  dd=a1*d2-a2*d1;
  if(fabs(dd)<.000000001) return(1);

  *x=((*(u1n+1)-*(u2n+1))*a1-(*(u1n-1)-*(u2n-1))*a2)/dd/x1;
  if((c1!=.0)&&(*x>100.))*x=atan(*x*c1)/c1;
  *r=((*(u1n-1)-*(u2n-1))*d2-(*(u1n+1)-*(u2n+1))*d1)/dd*nz;
  *r=*r-*x*r1*nz;
  return(1);
}




int CAnalysis::jdgz(double *u,double *i,double *i0,double *im0,int k,double *x,double *r)
{
 
  double d1,d2,dd,s;
  double *ik,*i0k,*im0k,*uk;
  
  ik=i+k;i0k=i0+k;im0k=im0+k;uk=u+k;
  *x=*(x-1);*r=*(r-1);
  d1=x1*(*ik-*(ik-2)+kl*(*i0k-*(i0k-2))+kml*(*im0k-*(im0k-2)))/dt
        +r1*(*(ik-1)+kr**(i0k-1)+kmr**(im0k-1));
  d2=x1*(*(ik+2)-*ik+kl*(*(i0k+2)-*i0k)+kml*(*(im0k+2)-*im0k))/dt
        +r1*(*(ik+1)+kr**(i0k+1)+kmr**(im0k+1));

  dd=*(i0k+1)*d1-*(i0k-1)*d2;
  if(fabs(dd)<.000000001)return(1);
  *x=(*(uk-1)**(i0k+1)-(*(uk+1)**(i0k-1)))/dd;

  if((*x<100.)||(!c0)||(!c1))
   {*r=(-*(uk-1)*d2+*(uk+1)*d1)/dd*nz; return (1);}
  
  *x=atan(c1**x)/c1;
  s=atan(c0**x)/c0/atan(c1**x)*c1;
  d1=x1*(*ik-*(ik-2)+kl*s*(*i0k-*(i0k-2))+kml*(*im0k-*(im0k-2)))/dt
        +r1*(*(ik-1)+kr**(i0k-1)+kmr**(im0k-1));
  d2=x1*(*(ik+2)-*ik+kl*s*(*(i0k+2)-*i0k)+kml*(*(im0k+2)-*im0k))/dt
        +r1*(*(ik+1)+kr**(i0k+1)+kmr**(im0k+1));

  dd=*(i0k+1)*d1-*(i0k-1)*d2;
  if(fabs(dd)<.000000001) return(1);
  *x=(*(uk-1)**(i0k+1)-(*(uk+1)**(i0k-1)))/dd;
  if(c1!=.0)*x=atan(*x*c1)/c1;
  *r=(-*(uk-1)*d2+*(uk+1)*d1)/dd*nz;
  return(1);
}


int CAnalysis::xjgz(double *u1,double *i1,double *u2,double *i2, int n,int k,double *x,double *r)
{
 double d1,d2,a1,a2,dd;
 double *i1n,*i2n,*i1k,*i2k,*u1n,*u2n;

 i1n=i1+n;
 i2n=i2+n;
 i1k=i1+k;
 
 i2k=i2+k;
 u1n=u1+n;
 u2n=u2+n;

 *x=*(x-1);*r=*(r-1);
 d1=x1*(*i1n-*(i1n-2)-*i2n+*(i2n-2))/dt+r1*(*(i1n-1)-*(i2n-1));
 d2=x1*(*(i1n+2)-*i1n-*(i2n+2)+*i2n)/dt+r1*(*(i1n+1)-*(i2n+1));
 a1=*(i1n-1)-*(i2n-1)-*(i1k-1)+*(i2k-1);
 a2=*(i1n+1)-*(i2n+1)-*(i1k+1)+*(i2k+1);

 dd=a1*d2-a2*d1;
 if(fabs(dd)<.000000001) return(1);
 
 *x=((*(u1n+1)-*(u2n+1))*a1-(*(u1n-1)-*(u2n-1))*a2)/dd;
 if((c1!=.0)&&(*x>100.))*x=atan(*x*c1)/c1;
 *r=((*(u1n-1)-*(u2n-1))*d2-(*(u1n+1)-*(u2n+1))*d1)/dd*nz;
 return(1);
}


int CAnalysis::tj(double *x,double *r,double *sq,double *sx,double *sr, double *srx,double *srr,int n)
{
 
 double dx,q,*xn,*rn;
 xn=x+n;rn=r+n; 
 
 if((*xn>2*jlzd)||(*xn<-5.)||(*rn<-15.0))return(0);
 dx=fabs(*xn-*(xn+1))+fabs(*xn-*(xn+2))+fabs(*xn-*(xn+3))+
   fabs(*xn-*(xn-1))+fabs(*xn-*(xn-2))+fabs(*xn-*(xn-3));
 q=100/(dx+.1+fabs(*rn));
 *sq+=q;
 *sx+=q**xn;
 *sr+=q**rn;
 *srx+=q**rn**xn;
 *srr+=q**rn**rn;
 return(1);
}




int CAnalysis::pqd2(double *i1,double *i2,double *i3,int *jj,int n)
{
 double a1,a2,b1,b2,c1,c2,ab,bc,ca;
 *jj=0;
 lb4(i1,&a1,n);
 lb4(i2,&b1,n);
 lb4(i3,&c1,n);
 
 lb4(i1,&a2,n-20);
 lb4(i2,&b2,n-20);
 lb4(i3,&c2,n-20);
 
 ab=fabs(a1-a2-b1+b2);
 bc=fabs(c1-c2-b1+b2);
 ca=fabs(a1-a2-c1+c2);
 
 if((3.5*ab<bc)||(3.5*ca<bc))return(0);
 if(fabs(a2-a1)>50./zzd)*jj=1;
 return(0);
}


int CAnalysis:: px2(double *u,double *i,int *jj,int n)
{
 double z,x,r,d1,dd,d2,*in,*un,in1,in2,in3,in4,in5,in6,un2,un5;
 in=i+n;un=u+n;