main.cpp

这个是应用pq分解法解电力系统潮流的方法

			 D_Q=F_YinZi_Result.D;
			 U_Q=F_YinZi_Result.U;
			 NUseq_Q=F_YinZi_Result.NUseq;
			 NUsum_Q=F_YinZi_Result.NUsum;
		 }
	 }
	 else
	 {
		 F_YinZi_Source_Type F_YinZi_Source;
		 {
			 F_YinZi_Source.flag=1;
			 F_YinZi_Source.Nn=Nn;
			 F_YinZi_Source.Npv=Npv;
			 F_YinZi_Source.Np=Np;
			 F_YinZi_Source.BalanceNode=BalanceNode;
			 F_YinZi_Source.PVnode=PVNode;
			 F_YinZi_Source.NYseq=NYseq;
			 F_YinZi_Source.NYsum=NYsum;
			 F_YinZi_Source.Yii=Yii1;
			 F_YinZi_Source.Yij=Yij1;
		 }
		 F_YinZi_Result_Type F_YinZi_Result=PowerFlow.F_YinZi(F_YinZi_Source);
		 {
			 D_P=F_YinZi_Result.D;
			 U_P=F_YinZi_Result.U;
			 NUseq_P=F_YinZi_Result.NUseq;
			 NUsum_P=F_YinZi_Result.NUsum;
		 }
	}

/////////////////////////////////////////////////////////////////////////////
// 	 for (i=1;i<=Nn;i++)
// 	 {
// 		 cout<<Yii[i].G<<"  "<<Yii[i].B<<endl;
// 	 }
// 	 for (i=1;i<=Nb;i++)
// 	 {
// 		 cout<<Yij[i].G<<"  "<<Yij[i].B<<endl;
// 	 }
// 	 for (i=1;i<=Nn+1;i++)
// 	 {
// 		 cout<<NYseq[i]<<"    "<<NYsum[i]<<endl;
// 	 }
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////传电压初值//////////////////////////////////////////////////////////////////////////

	 NodalVoltage_Type *NodalVoltage;

	 F_PassV0_Source_Type F_PassV0_Source;
	 {
		 F_PassV0_Source.Nn=Nn;
		 F_PassV0_Source.Node=Node;
	 }
	 F_PassV0_Result_Type F_PassV0_Result=PowerFlow.F_PassV0(F_PassV0_Source);
	 {
		 NodalVoltage=F_PassV0_Result.NodalVoltage;
	 }
	 

// 	 for (i=1;i<=Nn;i++)
// 	 {
// 		 cout<<NodalVoltage[i].V<<"   "<<NodalVoltage[i].Theta<<endl;
// 	 }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////迭代过程////////////////////////////////////////////////////////////////////////////

	 NodalPower_Type *NodalPower,*GenePower,*LoadPower;
	 NodalPower=new NodalPower_Type[Nn+1];
	 GenePower=new NodalPower_Type[Nn+1];
	 LoadPower=new NodalPower_Type[Nn+1];
	 double *DI;
	 DI=new double[Nn+1];
	 double MaxError[3];
	 int ErrorNode[3];
	 int Num_DieDai;
	 

	 for (i=1;i<=100;i++)
	 {
		 MaxError[0]=0;
		 for (flag=1;flag<=2;flag++)
		 {
			 F_CalculatePQ_Source_Type F_CalculatePQ_Source;
			 {
				 F_CalculatePQ_Source.flag=flag;
				 F_CalculatePQ_Source.Nn=Nn;
				 F_CalculatePQ_Source.Nb=Nb;
				 F_CalculatePQ_Source.NodalPower=NodalPower;
				 F_CalculatePQ_Source.NodalVoltage=NodalVoltage;
				 F_CalculatePQ_Source.NYseq=NYseq;
				 F_CalculatePQ_Source.Yii=Yii;
				 F_CalculatePQ_Source.Yij=Yij;
			 }
			 PowerFlow.F_CalculatePQ(F_CalculatePQ_Source);
			 F_FormDI_Source_Type F_FormDI_Source;
			 {
				 F_FormDI_Source.flag=flag;
				 F_FormDI_Source.Nn=Nn;
				 F_FormDI_Source.Ng=Ng;
				 F_FormDI_Source.Np=Np;
				 F_FormDI_Source.Npv=Npv;
				 F_FormDI_Source.BalanceNode=BalanceNode;
				 F_FormDI_Source.DI=DI;
				 F_FormDI_Source.GenePower=GenePower;
				 F_FormDI_Source.GeneratorNode=GeneratorNode;
				 F_FormDI_Source.LoadPower=LoadPower;
				 F_FormDI_Source.NodalVoltage=NodalVoltage;
				 F_FormDI_Source.NodalPower=NodalPower;
				 F_FormDI_Source.Node=Node;
				 F_FormDI_Source.PVNode=PVNode;
			 }
			 F_FormDI_Result_Type F_FormDI_Result=PowerFlow.F_FormDI(F_FormDI_Source);
			 {
				 ErrorNode[flag]=F_FormDI_Result.ErrorNode;
				 MaxError[flag]=F_FormDI_Result.MaxError;
			 }
			 
			 F_QiuJie_Source_Type F_QiuJie_Source;
			 {
				 if (flag==1)
				 {
					 F_QiuJie_Source.D=D_P;
					 F_QiuJie_Source.U=U_P;
					 F_QiuJie_Source.DI=DI;
					 F_QiuJie_Source.Nn=Nn;
					 F_QiuJie_Source.NUsum=NUsum_P;
				 }
				 else
				 {
					 F_QiuJie_Source.D=D_Q;
					 F_QiuJie_Source.U=U_Q;
					 F_QiuJie_Source.DI=DI;
					 F_QiuJie_Source.Nn=Nn;
					 F_QiuJie_Source.NUsum=NUsum_Q;
				 }
			 }
			 PowerFlow.F_QiuJie(F_QiuJie_Source);
			 for (j=1;j<=Nn;j++)
			 {
				 if (flag==1)
				 {
					 NodalVoltage[j].Theta-=DI[j]/NodalVoltage[j].V;
				 }
				 else
				 {
					 NodalVoltage[j].V-=DI[j];
				 }
			 }
		 }

		 MaxError[0]=(MaxError[1]>MaxError[2]?MaxError[1]:MaxError[2]);
		 
		 if (MaxError[0]<epsilon)
		 {
			 break;
		 }
 	 }

	 Num_DieDai=i;

// 	 cout<<Num_DieDai<<endl;
// 	 for (i=1;i<=Nn;i++)
// 	 {
// 		 cout<<NodalVoltage[i].V<<"   "<<NodalVoltage[i].Theta<<endl;
// 	 }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////节点输出数据的形成/////////////////////////////////////////////////////////////////
	 NodeOutData_Type *NodeOutData;
	NodeOutData=new NodeOutData_Type[Nn+1];

	 F_NodeDataOut_Source_Type F_NodeDataOut_Source;
	 {
		 F_NodeDataOut_Source.Nn=Nn;
		 F_NodeDataOut_Source.Ng=Ng;
		 F_NodeDataOut_Source.Np=Np;
		 F_NodeDataOut_Source.BalanceNode=BalanceNode;
		 F_NodeDataOut_Source.GeneratorNode=GeneratorNode;
		 F_NodeDataOut_Source.GenePower=GenePower;
		 F_NodeDataOut_Source.LoadPower=LoadPower;
		 F_NodeDataOut_Source.NodalVoltage=NodalVoltage;
		 F_NodeDataOut_Source.NodeOutData=NodeOutData;
	 }
	 PowerFlow.F_NodeDataOut(F_NodeDataOut_Source);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////支路输出数据的形成/////////////////////////////////////////////////////////////////
	 BranchOutData_Type *BranchOutData;
	 BranchOutData=new BranchOutData_Type[Nb+1];
	 double P_Loss,Q_Loss;
	 
	 F_BranchDataOut_Source_Type F_BranchDataOut_Source;
	 {
		 F_BranchDataOut_Source.Branch=Branch;
		 F_BranchDataOut_Source.Nb=Nb;
		 F_BranchDataOut_Source.NodalVoltage=NodalVoltage;
		 F_BranchDataOut_Source.BranchOutData=BranchOutData;
	 }
	 F_BranchDataOut_Result_Type F_BranchDataOut_Result=PowerFlow.F_BranchDataOut(F_BranchDataOut_Source);
	 {
		 P_Loss=F_BranchDataOut_Result.P_loss;
		 Q_Loss=F_BranchDataOut_Result.Q_loss;
	 }



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////节点还原///////////////////////////////////////////////////////////////////////

	 F_NodeOpt1_Source_Type F_NodeOpt1_Source;
	 {
		 F_NodeOpt1_Source.Nn=Nn;
		 F_NodeOpt1_Source.Nb=Nb;
		 F_NodeOpt1_Source.BranchOutData=BranchOutData;
		 F_NodeOpt1_Source.NodeOutData=NodeOutData;
		 F_NodeOpt1_Source.NodeOptArray=NodeOptArray;
	 }

	 PowerFlow.F_NodeOpt1(F_NodeOpt1_Source);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////输出数据///////////////////////////////////////////////////////////////////////

	 F_OutData_Source_Type F_OutData_Source;
	 {
		 F_OutData_Source.Nn=Nn;
		 F_OutData_Source.NodeOutData=NodeOutData;
		 F_OutData_Source.Nb=Nb;
		 F_OutData_Source.BranchOutData=BranchOutData;
	 }
	 PowerFlow.F_OutData(F_OutData_Source);
	 
	 cout<<"迭代次数:"<<Num_DieDai<<endl
		 <<"节点数据和支路数据见程序目录下的Result.txt文件。"<<endl;



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}