powerflow_type.cpp

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

	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;
				}
			}
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////