main.cpp

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

#include "iostream.h"
#include "fstream.h"
#include "iomanip.h"
 


#include "PowerFlow_Type.h"


void main()
{
	PowerFlow_Type PowerFlow;
	int i,j,flag;
	int BX_XB_Flag=1;//BX法和XB法的标记量；1为BX法，2为XB法；

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////获取数据/////////////////////////////////////////////////////////////////////
	int Nn,Ng,Nb;
	double V0,Theta0,epsilon;
	Node_Type *Node;
	GeneratorNode_Type *GeneratorNode;
	Branch_Type *Branch;

	F_GetData_Result_Type F_GetData_Result=PowerFlow.F_GetData();
	{
		Nn=F_GetData_Result.Nn;
		Ng=F_GetData_Result.Ng;
		Nb=F_GetData_Result.Nb;
		V0=F_GetData_Result.V0;
		Theta0=F_GetData_Result.Theta0;
		epsilon=F_GetData_Result.epsilon;
		Node=F_GetData_Result.Node;
		GeneratorNode=F_GetData_Result.GeneratorNode;
		Branch=F_GetData_Result.Branch;
	}

// 	//////////////////////////////////////////////////////////////////////////
// 	cout<<Nn<<"  "<<Ng<<"  "<<Nb<<"  "<<V0<<"  "<<Theta0<<"  "<<epsilon<<"  "<<endl;
// 	cout<<GeneratorNode[1].P;
// 	//////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////节点优化///////////////////////////////////////////////////////////////////////

	int *NodeOptArray=new int[Nn+1];
	for (i=1;i<=Nn;i++)
	{
		NodeOptArray[i]=i;
	}

	F_NodeOpt_Source_Type F_NodeOpt_Source;
	{
		F_NodeOpt_Source.Nn=Nn;
		F_NodeOpt_Source.Ng=Ng;		
		F_NodeOpt_Source.Nb=Nb;
		F_NodeOpt_Source.Node=Node;
		F_NodeOpt_Source.GeneratorNode=GeneratorNode;
		F_NodeOpt_Source.Branch=Branch;
		F_NodeOpt_Source.NodeOptArray=NodeOptArray;
	}
	 PowerFlow.F_NodeOpt(F_NodeOpt_Source);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////统计PV节点和平衡节点/////////////////////////////////////////////////////////////////

	int Npv,Np;
	PVNode_Type *PVNode;
	BalanceNode_Type *BalanceNode;
	F_FormPVandBalanceNode_Source_Type F_FormPVandBalanceNode_Source;
	{
		F_FormPVandBalanceNode_Source.Nn=Nn;
		F_FormPVandBalanceNode_Source.Node=Node;
	}
	F_FormPVandBalanceNode_Result_Type F_FormPVandBalanceNode_Result=PowerFlow.F_FormPVandBalanceNode(F_FormPVandBalanceNode_Source);
	{
		Npv=F_FormPVandBalanceNode_Result.Npv;
		PVNode=F_FormPVandBalanceNode_Result.PVNode;
		Np=F_FormPVandBalanceNode_Result.Np;
		BalanceNode=F_FormPVandBalanceNode_Result.BalanceNode;
	}

// 	cout<<Npv<<endl<<PVNode[1].n<<"  "<<PVNode[1].V<<endl;
// 	cout<<Np<<endl<<BalanceNode[1].n<<"  "<<BalanceNode[1].V<<"  "<<BalanceNode[1].Theta<<endl;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////支路排序////////////////////////////////////////////////////////////////////////////
	F_BranchPaiXu_Source_Type F_BranchPaiXu_Source;
	{
		F_BranchPaiXu_Source.Nb=Nb;
		F_BranchPaiXu_Source.Branch=Branch;
	}
	PowerFlow.F_BranchPaiXu(F_BranchPaiXu_Source);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////节点排序////////////////////////////////////////////////////////////////////////////
	F_NodePaiXu_Source_Type F_NodePaiXu_Source;
	{
		F_NodePaiXu_Source.Nn=Nn;
		F_NodePaiXu_Source.Ng=Ng;
		F_NodePaiXu_Source.Node=Node;
		F_NodePaiXu_Source.GeneratorNode=GeneratorNode;
	}
	PowerFlow.F_NodePaixu(F_NodePaiXu_Source);

	//////////////////////////////////////////////////////////////////////////////////////////////
// 	for (i=1;i<=Nn;i++)
// 	{
// 		cout<<Node[i].n<<"    "<<Node[i].P<<"    "<<Node[i].Q
// 			<<"    "<<Node[i].V<<"    "<<Node[i].Theta<<endl;
// 	}
// 	cout<<endl;
// 	for (i=1;i<=Ng;i++)
// 	{
// 		cout<<GeneratorNode[i].n<<"   "<<GeneratorNode[i].P<<"    "<<GeneratorNode[i].Q<<endl;
// 	}
// 	cout<<endl;
// 	for (i=1;i<=Nb;i++)
// 	{
// 		cout<<Branch[i].n1<<"     "<<Branch[i].n2<<"     "<<Branch[i].R
// 			<<"     "<<Branch[i].X<<"     "<<Branch[i].YK<<endl;
// 	}
// 	cout<<endl;
// 	for (i=1;i<=Npv;i++)
// 	{
// 		cout<<PVNode[i].n<<"   "<<PVNode[i].V<<endl;
// 	}
// 	cout<<endl;
// 	for (i=1;i<=Np;i++)
// 	{
// 		cout<<BalanceNode[i].n<<"    "<<BalanceNode[i].V<<"    "<<BalanceNode[i].Theta<<endl;
// 	}
	//////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////形成导纳矩阵第一步,不考虑接地支路的影响///////////////////////////////////////////////////////
	int *NYseq;
	int *NYsum;
	Yii_Type *Yii;
	Yii_Type *Yii1;
	Yij_Type *Yij;
	Yij_Type *Yij1;

	double *D_P,*D_Q;
	U_Type *U_P,*U_Q;
	int *NUsum_P,*NUsum_Q;
	int *NUseq_P,*NUseq_Q;
	
	F_YForm1_Source_Type F_YForm1_Source;
	{
		F_YForm1_Source.Nn=Nn;
		F_YForm1_Source.Nb=Nb;
		F_YForm1_Source.Branch=Branch;
	}
	F_YForm1_Result_Type F_YForm1_Result=PowerFlow.F_YForm1(F_YForm1_Source);
	{	
		NYseq=F_YForm1_Result.NYseq;
		NYsum=F_YForm1_Result.NYsum;
		Yii=F_YForm1_Result.Yii;
		Yii1=F_YForm1_Result.Yii1;
		Yij=F_YForm1_Result.Yij;
		Yij1=F_YForm1_Result.Yij1;
	}

	if (BX_XB_Flag==1)
	{
		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=Yii;
			F_YinZi_Source.Yij=Yij;
			
		}
		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;
		}
	}
	else
	{
		F_YinZi_Source_Type F_YinZi_Source;
		{
			F_YinZi_Source.flag=2;
			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=Yii;
			F_YinZi_Source.Yij=Yij;
		}
		F_YinZi_Result_Type F_YinZi_Result=PowerFlow.F_YinZi(F_YinZi_Source);
		{
			D_Q=F_YinZi_Result.D;
			U_Q=F_YinZi_Result.U;
			NUseq_Q=F_YinZi_Result.NUseq;
			NUsum_Q=F_YinZi_Result.NUsum;
		}
	}	

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////形成导纳矩阵第二步,追加接地支路//////////////////////////////////////////////////////////

	F_YForm2_Source_Type F_YForm2_Source;
	{
		F_YForm2_Source.Nn=Nn;
		F_YForm2_Source.Nb=Nb;
		F_YForm2_Source.Branch=Branch;
		F_YForm2_Source.Yii=Yii;
		F_YForm2_Source.Yii1=Yii1;
		F_YForm2_Source.Yij=Yij;
		F_YForm2_Source.Yij1=Yij1;
	}
	 PowerFlow.F_YForm2(F_YForm2_Source);

	 if (BX_XB_Flag==1)
	 {
		 F_YinZi_Source_Type F_YinZi_Source;
		 {
			 F_YinZi_Source.flag=2;
			 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);
		 {