?? powerflow_type.cpp
字號:
Node_Type *Node=F_PassV0_Source.Node;
NodalVoltage_Type *NodalVoltage;
NodalVoltage=new NodalVoltage_Type[Nn+1];
int i;
for (i=1;i<=Nn;i++)
{
NodalVoltage[i].V=Node[i].V;
NodalVoltage[i].Theta=Node[i].Theta;
}
F_PassV0_Result_Type F_PassV0_Result;
{
F_PassV0_Result.NodalVoltage=NodalVoltage;
}
return F_PassV0_Result;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////迭代過程中節點功率的計算/////////////////////////////////////////////////////////////
void PowerFlow_Type::F_CalculatePQ(F_CalculatePQ_Source_Type F_CalculatePQ_Source)
{
int flag=F_CalculatePQ_Source.flag,Nn=F_CalculatePQ_Source.Nn,Nb=F_CalculatePQ_Source.Nb;
NodalVoltage_Type *NodalVoltage=F_CalculatePQ_Source.NodalVoltage;
NodalPower_Type *NodalPower=F_CalculatePQ_Source.NodalPower;
Yii_Type *Yii=F_CalculatePQ_Source.Yii;
Yij_Type *Yij=F_CalculatePQ_Source.Yij;
int *NYseq=F_CalculatePQ_Source.NYseq;
int i,j,n;
double Vi,Vj,Theta_ij,Ai,Bi;
if (flag==1)
{
for (i=1;i<=Nn;i++)
{
NodalPower[i].P=0.0;
}
}
else
{
for (i=1;i<=Nn;i++)
{
NodalPower[i].Q=0.0;
}
}
for (i=1;i<=Nn;i++)
{
Vi=NodalVoltage[i].V;
if (flag==1)
{
Ai=Yii[i].G;
NodalPower[i].P+=Vi*Vi*Ai;
}
else
{
Ai=-Yii[i].B;
NodalPower[i].Q+=Vi*Vi*Ai;
}
for (n=NYseq[i];n<NYseq[i+1];n++)
{
j=Yij[n].n2;
Vj=NodalVoltage[j].V;
Theta_ij=NodalVoltage[i].Theta-NodalVoltage[j].Theta;
if (flag==1)
{
Ai=Yij[n].G;
Bi=Yij[n].B;
NodalPower[i].P+=Vi*Vj*(Ai*cos(Theta_ij)+Bi*sin(Theta_ij));
NodalPower[j].P+=Vi*Vj*(Ai*cos(Theta_ij)-Bi*sin(Theta_ij));
}
else
{
Ai=-Yij[n].B;
Bi=Yij[n].G;
NodalPower[i].Q+=Vi*Vj*(Ai*cos(Theta_ij)+Bi*sin(Theta_ij));
NodalPower[j].Q+=Vi*Vj*(Ai*cos(Theta_ij)-Bi*sin(Theta_ij));
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////求最大功率誤差以及DeltaI/////////////////////////////////////////////////////////////
F_FormDI_Result_Type PowerFlow_Type::F_FormDI(F_FormDI_Source_Type F_FormDI_Source)
{
int flag=F_FormDI_Source.flag,Nn=F_FormDI_Source.Nn,Npv=F_FormDI_Source.Npv,Np=F_FormDI_Source.Np,Ng=F_FormDI_Source.Ng;
double *DI=F_FormDI_Source.DI;
NodalPower_Type *NodalPower=F_FormDI_Source.NodalPower,*GenePower=F_FormDI_Source.GenePower,*LoadPower=F_FormDI_Source.LoadPower;
NodalVoltage_Type *NodalVoltage=F_FormDI_Source.NodalVoltage;
PVNode_Type *PVNode=F_FormDI_Source.PVNode;
BalanceNode_Type *BalanceNode=F_FormDI_Source.BalanceNode;
Node_Type *Node=F_FormDI_Source.Node;
GeneratorNode_Type *GeneratorNode=F_FormDI_Source.GeneratorNode;
double MaxError=0.0;
int ErrorNode;
int i_g=1,n_g=GeneratorNode[1].n;
int i_pv=1,n_pv=PVNode[1].n;
int i_balance=1,n_balance=BalanceNode[1].n;
int i;
double Vi,Wi;
for (i=1;i<=Nn;i++)
{
Vi=NodalVoltage[i].V;
if (flag==1)
{
LoadPower[i].P=Node[i].P;
Wi=Node[i].P+NodalPower[i].P;
GenePower[i].P=Wi;
Wi=-Wi;
if (i==n_g&&i_g<=Ng)
{
Wi=GeneratorNode[i_g].P+Wi;
i_g++;
n_g=GeneratorNode[i_g].n;
}
}
else
{
LoadPower[i].Q=Node[i].Q;
Wi=Node[i].Q+NodalPower[i].Q;
GenePower[i].Q=Wi;
Wi=-Wi;
if (i==n_g&&i_g<=Ng)
{
Wi=GeneratorNode[i_g].Q+Wi;
i_g++;
n_g=GeneratorNode[i_g].n;
}
}
if (i==n_balance&&i_balance<=Np)
{
i_balance++;
n_balance=BalanceNode[i_balance].n;
DI[i]=0;
continue;
}
else if (flag==2&&i==n_pv&&i_pv<=Npv)
{
i_pv++;
n_pv=PVNode[i_pv].n;
DI[i]=0;
continue;
}
else
{
if (fabs(Wi)>MaxError)
{
MaxError=fabs(Wi);
ErrorNode=i;
}
DI[i]=Wi/Vi;
}
}
F_FormDI_Result_Type F_FormDI_Result;
{
F_FormDI_Result.MaxError=MaxError;
F_FormDI_Result.ErrorNode=ErrorNode;
}
return F_FormDI_Result;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////線性方程組的求解////////////////////////////////////////////////////////////////
void PowerFlow_Type::F_QiuJie(F_QiuJie_Source_Type F_QiuJie_Source)
{
int Nn=F_QiuJie_Source.Nn;
double *DI=F_QiuJie_Source.DI;
U_Type *U=F_QiuJie_Source.U;
int *NUsum=F_QiuJie_Source.NUsum;
double *D=F_QiuJie_Source.D;
int i,j,n2;
int i_u=1;
for (i=1;i<=Nn;i++)
{
for (j=1;j<=NUsum[i];j++)
{
n2=U[i_u].n2;
DI[n2]=DI[n2]-U[i_u].value*DI[i];
i_u++;
}
DI[i]=DI[i]*D[i];
}
for (i=Nn;i>=1;i--)
{
for (j=1;j<=NUsum[i];j++)
{
i_u--;
n2=U[i_u].n2;
DI[i]=DI[i]-U[i_u].value*DI[n2];
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////節點輸出數據的形成/////////////////////////////////////////////////////////////////
void PowerFlow_Type::F_NodeDataOut(F_NodeDataOut_Source_Type F_NodeDataOut_Source)//節點輸出數據的形成；
{
int Nn=F_NodeDataOut_Source.Nn,Ng=F_NodeDataOut_Source.Ng,Np=F_NodeDataOut_Source.Np;
BalanceNode_Type *BalanceNode=F_NodeDataOut_Source.BalanceNode;
GeneratorNode_Type *GeneratorNode=F_NodeDataOut_Source.GeneratorNode;
NodalVoltage_Type *NodalVoltage=F_NodeDataOut_Source.NodalVoltage;
NodalPower_Type *GenePower=F_NodeDataOut_Source.GenePower,*LoadPower=F_NodeDataOut_Source.LoadPower;
NodeOutData_Type *NodeOutData=F_NodeDataOut_Source.NodeOutData;
int i;
int i_g=1,n_g=GeneratorNode[1].n;
int i_balance=1,n_balance=BalanceNode[1].n;
double V,Theta,P,Q;
for (i=1;i<=Nn;i++)
{
Theta=NodalVoltage[i].Theta*180/3.1415926535898;
V=NodalVoltage[i].V;
if (i==n_g&&i_g<=Ng)
{
P=GenePower[i].P;
Q=GenePower[i].Q;
i_g++;
n_g=GeneratorNode[i_g].n;
}
else if (i==n_balance&&i_balance<=Np)
{
P=GenePower[i].P;
Q=GenePower[i].Q;
i_balance++;
n_balance=BalanceNode[i_balance].n;
}
else
{
P=0;
Q=0;
}
NodeOutData[i].n=i;
NodeOutData[i].V=V;
NodeOutData[i].Theta=Theta;
NodeOutData[i].P_g=P;
NodeOutData[i].Q_g=Q;
NodeOutData[i].P_l=LoadPower[i].P;
NodeOutData[i].Q_l=LoadPower[i].Q;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////支路輸出數據的形成/////////////////////////////////////////////////////////////////
F_BranchDataOut_Result_Type PowerFlow_Type::F_BranchDataOut(F_BranchDataOut_Source_Type F_BranchDataOut_Source)//支路輸出數據的形成；
{
BranchOutData_Type *BranchOutData=F_BranchDataOut_Source.BranchOutData;
int Nb=F_BranchDataOut_Source.Nb;
Branch_Type *Branch=F_BranchDataOut_Source.Branch;
NodalVoltage_Type *NodalVoltage=F_BranchDataOut_Source.NodalVoltage;
double P_loss,Q_loss;
int n,i,j;
double R,X,YK,Vi,Vj,Theta,Ei,Fi,Ej,Fj,DE,DF,Zmag2,Ir,Ii,Pij,Qij,Pji,Qji;
P_loss=Q_loss=0;
for (n=1;n<=Nb;n++)
{
i=abs(Branch[n].n1);
j=abs(Branch[n].n2);
R=Branch[n].R;
X=Branch[n].X;
YK=Branch[n].YK;
Vi=NodalVoltage[i].V;
Theta=NodalVoltage[i].Theta;
Ei=Vi*cos(Theta);
Fi=Vi*sin(Theta);
Vj=NodalVoltage[j].V;
Theta=NodalVoltage[j].Theta;
Ej=Vj*cos(Theta);
Fj=Vj*sin(Theta);
if (Branch[n].n1<0||Branch[n].n2<0)
{
if (Branch[n].n1<0)
{
Ei=Ei/YK;
Fi=Fi/YK;
}
else
{
Ej=Ej/YK;
Fj=Fj/YK;
}
YK=0;
}
DE=Ei-Ej;DF=Fi-Fj;
Zmag2=R*R+X*X;
Ir=(DE*R+DF*X)/Zmag2;
Ii=(DF*R-DE*X)/Zmag2;
Pij=Ir*Ei+Ii*Fi;
Qij=Ir*Fi-Ii*Ei;
Pji=-Ir*Ej-Ii*Fj;
Qji=-Ir*Fj+Ii*Ej;
Qij=Qij-Vi*Vi*YK/2.0;
Qji=Qji-Vj*Vj*YK/2.0;
P_loss=P_loss+Pij+Pji;
Q_loss=Q_loss+Qij+Qji;
BranchOutData[n].i=i;
BranchOutData[n].j=j;
BranchOutData[n].Pij=Pij;
BranchOutData[n].Pji=Pji;
BranchOutData[n].Qij=Qij;
BranchOutData[n].Qji=Qji;
}
F_BranchDataOut_Result_Type F_BranchDataOut_Result;
{
F_BranchDataOut_Result.P_loss=P_loss;
F_BranchDataOut_Result.Q_loss=Q_loss;
}
return F_BranchDataOut_Result;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////輸出數據///////////////////////////////////////////////////////////////////////
void PowerFlow_Type::F_OutData(F_OutData_Source_Type F_OutData_Source)//輸出數據；
{
int Nn=F_OutData_Source.Nn,Nb=F_OutData_Source.Nb;
NodeOutData_Type *NodeOutData=F_OutData_Source.NodeOutData;
BranchOutData_Type *BranchOutData=F_OutData_Source.BranchOutData;
int i;
ofstream fout("Result.txt");
// fout.precision(3);
// fout.setf(ios::fixed);
fout<<"節點數據："<<endl;
fout<<setw(8)<<"節點號"
<<setw(16)<<"電壓幅值"<<setw(16)<<"電壓相角(°)"
<<setw(16)<<"負荷有功"<<setw(16)<<"負荷無功"
<<setw(16)<<"發電機有功"<<setw(16)<<"發電機無功"<<endl;
for (i=1;i<=Nn;i++)
{
fout<<setw(8)<<NodeOutData[i].n
<<setw(16)<<NodeOutData[i].V<<setw(16)<<NodeOutData[i].Theta
<<setw(16)<<NodeOutData[i].P_l<<setw(16)<<NodeOutData[i].Q_l
<<setw(16)<<NodeOutData[i].P_g<<setw(16)<<NodeOutData[i].Q_g<<endl;
}
fout<<endl;
fout<<"支路數據："<<endl;
fout<<setw(10)<<"節點i"<<setw(10)<<"節點j"
<<setw(16)<<"Pij"<<setw(16)<<"Qij"
<<setw(16)<<"Pji"<<setw(16)<<"Qji"
<<setw(16)<<"P_loss"<<setw(16)<<"Q_loss"<<endl;
for (i=1;i<=Nb;i++)
{
fout<<setw(10)<<BranchOutData[i].i<<setw(10)<<BranchOutData[i].j
<<setw(16)<<BranchOutData[i].Pij<<setw(16)<<BranchOutData[i].Qij
<<setw(16)<<BranchOutData[i].Pji<<setw(16)<<BranchOutData[i].Qji
<<setw(16)<<BranchOutData[i].Pij+BranchOutData[i].Pji
<<setw(16)<<BranchOutData[i].Qij+BranchOutData[i].Qji
<<endl;
}
fout.close;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////節點優化///////////////////////////////////////////////////////////////////////
void PowerFlow_Type::F_NodeOpt(F_NodeOpt_Source_Type F_NodeOpt_Source)//節點優化
{
int Nn=F_NodeOpt_Source.Nn,Ng=F_NodeOpt_Source.Ng,Nb=F_NodeOpt_Source.Nb;
Node_Type *Node=F_NodeOpt_Source.Node;
GeneratorNode_Type *GeneratorNode=F_NodeOpt_Source.GeneratorNode;
Branch_Type *Branch=F_NodeOpt_Source.Branch;
int *NodeOptArray=F_NodeOpt_Source.NodeOptArray;
struct ArrayTemp_Type
{
int n,sum;
}*ArrayTemp;
ArrayTemp=new ArrayTemp_Type[Nn+1];
int *NodeOptArray1=new int[Nn+1];
int i,j,n1,n2;
for (i=1;i<=Nn;i++)
{
ArrayTemp[i].n=i;
ArrayTemp[i].sum=0;
}
for (i=1;i<=Nb;i++)
{
n1=abs(Branch[i].n1);
n2=abs(Branch[i].n2);
ArrayTemp[n1].sum++;
ArrayTemp[n2].sum++;
}
for (i=1;i<=Nn-1;i++)
{
for (j=i+1;j<=Nn;j++)
{
if (ArrayTemp[i].sum>ArrayTemp[j].sum)
{
ArrayTemp_Type Temp;
Temp=ArrayTemp[i];
ArrayTemp[i]=ArrayTemp[j];
ArrayTemp[j]=Temp;
}
}
}
for (i=1;i<=Nn;i++)
{
NodeOptArray[i]=ArrayTemp[i].n;
}
for (i=1;i<=Nn;i++)
{
NodeOptArray1[NodeOptArray[i]]=i;
}
for (i=1;i<=Nn;i++)
{
Node[i].n=NodeOptArray1[Node[i].n];
}
for (i=1;i<=Ng;i++)
{
GeneratorNode[i].n=NodeOptArray1[GeneratorNode[i].n];
}
for (i=1;i<=Nb;i++)
{
n1=abs(Branch[i].n1);
n2=abs(Branch[i].n2);
if (Branch[i].n1>0)
{
n1=NodeOptArray1[n1];
}
else
{
n1=-NodeOptArray1[n1];
}
if (Branch[i].n2>0)
{
n2=NodeOptArray1[n2];
}
else
{
n2=-NodeOptArray1[n2];
}
Branch[i].n1=n1;
Branch[i].n2=n2;
}
delete ArrayTemp;
delete NodeOptArray1;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////節點還原///////////////////////////////////////////////////////////////////////
void PowerFlow_Type::F_NodeOpt1(F_NodeOpt1_Source_Type F_NodeOpt1_Source)
{
int Nn=F_NodeOpt1_Source.Nn,Nb=F_NodeOpt1_Source.Nb;
int *NodeOptArray=F_NodeOpt1_Source.NodeOptArray;
BranchOutData_Type *BranchOutData=F_NodeOpt1_Source.BranchOutData;
NodeOutData_Type *NodeOutData=F_NodeOpt1_Source.NodeOutData;
int i,j;
for (i=1;i<=Nn;i++)
{
NodeOutData[i].n=NodeOptArray[NodeOutData[i].n];
}
for (i=1;i<=Nn;i++)
{
for (j=i+1;j<=Nn;j++)
{
if (NodeOutData[i].n>NodeOutData[j].n)
{
NodeOutData_Type temp;
temp=NodeOutData[i];
NodeOutData[i]=NodeOutData[j];
NodeOutData[j]=temp;
}
}
}
for (i=1;i<=Nb;i++)
{
BranchOutData[i].i=NodeOptArray[BranchOutData[i].i];
BranchOutData[i].j=NodeOptArray[BranchOutData[i].j];
}
for (i=1;i<=Nb;i++)
{
if (BranchOutData[i].i>BranchOutData[i].j)
{
int temp;
temp=BranchOutData[i].i;
BranchOutData[i].i=BranchOutData[i].j;
BranchOutData[i].j=temp;
double tt;
tt=BranchOutData[i].Pij;
BranchOutData[i].Pij=BranchOutData[i].Pji;
BranchOutData[i].Pji=tt;
tt=BranchOutData[i].Qij;
BranchOutData[i].Qij=BranchOutData[i].Qji;
BranchOutData[i].Qji=tt;
}
}
for (i=1;i<=Nb;i++)
{
for (j=i+1;j<=Nb;j++)
{
if (BranchOutData[i].i>BranchOutData[j].i)
{
BranchOutData_Type temp;
temp=BranchOutData[i];
BranchOutData[i]=BranchOutData[j];
BranchOutData[j]=temp;
}
else if (BranchOutData[i].i==BranchOutData[j].i)
{
if (BranchOutData[i].j>BranchOutData[j].j)
{
BranchOutData_Type temp;
temp=BranchOutData[i];
BranchOutData[i]=BranchOutData[j];
BranchOutData[j]=temp;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -