dnet.cpp

这是一个简单能量损耗代码测试源代码

#include"stdafx.h"
#include <stdio.h> 
#include <windows.h> 
#include "DNet.h"



////////////////////////////////
//CBranch Operation
//////////////////////////////////

CBranch::~CBranch()
{
}

CBranch::CBranch()
{
}




void CBranch::AddTrans(double PFaultWaste,double VFault,double PKong,
		double KCurrent,double STotal,double GVoltage)
{
	m_wR=PFaultWaste*GVoltage*GVoltage*1000/(STotal*STotal);
	m_wX=VFault*GVoltage*GVoltage*10/STotal;
	double ZZ=m_wR*m_wR+m_wX*m_wX;
	m_wG=m_wR/sqrt(ZZ);
	m_wB=-m_wX/sqrt(ZZ);
}

void CBranch::SetRX(double r,double x,double RB,double XB)
{
	m_wR=r;
	m_wX=x;
	m_wRB=RB;
	m_wXB=XB;
	double ZZ=r*r+x*x;
	m_wG=r/sqrt(ZZ);
	m_wB=-x/sqrt(ZZ);
}

void CBranch::SetNode(UINT head,UINT tail)
{
	m_nHeadNode=head;
	m_nTailNode=tail;

	m_nHeadElement=head;
	m_nTailElement=tail;

}

void CBranch::SetBranchState(UINT nINdex,BOOL bState)
{
	m_bState=bState;
}
void CBranch::SetRatio(double voltage,double position)
{
	m_wRatio=voltage*(1+position)/0.4;
	m_wB=m_wB/m_wRatio;
	m_wG=m_wG/m_wRatio;
}


//////////////////////////////////////////////////
///CDNet operation
//////////////////////////////////////////////

CDNet::~CDNet()
{
	//todo add code
}

CDNet::CDNet()
{
	m_nDNetInfo.nBranch=0;
	m_nDNetInfo.nTBranch=0;
	m_nDNetInfo.nNode=0;
	m_nDNetInfo.nMaxElement=0;
	m_nDNetInfo.nFeederRoot=0;
	m_nDNetInfo.nTransBranch=0;
	m_nDNetInfo.nCable=0;
	m_nDNetInfo.nCap=0;
	m_nDNetInfo.m_bMark=1;
	m_nDNetInfo.nMaxIteration=5;
	m_nDNetInfo.nSubSystem=0;
	m_nDNetInfo.bNetChange=1;
	m_nDNetInfo.nLoad=0;
	m_nDNetInfo.nSwitch=0;

	m_nDNetInfo.wDNetPWaste=0;

}


void CDNet::Initialization()
{
	for(int i=0;i<=12;++i)
	{
		for(int j=0;j<=4;++j)
			CableData[i][j]=0;
	}

	for(i=0;i<=14;++i)
	{
		for(int j=0;j<=2;++j)
			BranchData[i][j]=0;
	}

	SetBranchTable();
	SetCableTable();
}

void CDNet::SetCableTable()
{
	int i=1;
	FILE* fp;
	fp=fopen("CableTable.dat","r");
	while(!feof(fp))
	{
		   fscanf(fp,"%f%f%f%f",&CableData[i][1],&CableData[i][2],
			   &CableData[i][3],&CableData[i][4]);
		   ++i;
	}
	fclose(fp);
}

void CDNet::SetBranchTable()
{
	int i=1;
	FILE* fp;
	fp=fopen("BranchTable.dat","r");
	while(!feof(fp))
	{
		fscanf(fp,"%f%f",&BranchData[i][1],&BranchData[i][2]);
		++i;
	}
	fclose(fp);
}



//deflaut


void CDNet::SetFeederInfo(UINT nIndex,INT nElement,double voltage)
{
	m_nFeederRoot.SetAt(nIndex,nElement);
	m_nNewFeederRoot.SetAt(nIndex,nElement);
	m_nFeederVoltage.SetAt(nIndex,voltage);
	double i=m_nFeederVoltage[nIndex];
}
void CDNet::SetBranchRX(double BranchArea,double distance,double& r,double& x,
						double& RB,double& XB)
{
	int mark;
	if(BranchArea==16)mark=1;
	if(BranchArea==25)mark=2;
	if(BranchArea==35)mark=3;
	if(BranchArea==50)mark=4;
	if(BranchArea==70)mark=5;
	if(BranchArea==95)mark=6;
	if(BranchArea==120)mark=7;
	if(BranchArea==150)mark=8;
	if(BranchArea==185)mark=9;
	if(BranchArea==210)mark=10;
	if(BranchArea==240)mark=11;
	if(BranchArea==300)mark=12;
	if(BranchArea==400)mark=13;
	if(BranchArea==500)mark=14;
	r=BranchData[mark][1]*distance;
	x=BranchData[mark][2]*distance;

	RB=r*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
	XB=x*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
}	                                                         

void CDNet::SetBranch(UINT nIndex,BOOL state,UINT head,UINT tail,double BranchArea,
					  double distance)
{
	CBranch* pBranch;
	double r=0,x=0,RB=0,XB=0;
	nIndex=nIndex+m_nDNetInfo.nTransBranch+m_nDNetInfo.nCable;
	if(!m_nBranchMap.Lookup(nIndex,pBranch))
	{
		pBranch=new CBranch;
		m_nBranchMap[nIndex]=pBranch;
		++m_nDNetInfo.nBranch;
		SetBranchRX(BranchArea,distance,r,x,RB,XB);
		pBranch->SetRX(r,x,RB,XB);
		pBranch->SetNode(head,tail);
		pBranch->SetBranchState(nIndex,state);
		pBranch->m_nType=BRANCH;
	}
	pBranch->m_bHeadMark=0;
	pBranch->m_bTailMark=0;
	pBranch->m_bBranchMark=1;
	pBranch->m_wPHead=0;
	pBranch->m_wPTail=0;
	pBranch->m_wQHead=0;
	pBranch->m_wQTail=0;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nHeadNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nHeadNode;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nTailNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nTailNode;
}

void CDNet::SetTrans(UINT nIndex,BOOL state,UINT head,UINT tail,double PFaultWaste,double VFault,double PKong,
		double KCurrent,double STotal,double GVoltage,double position)
{
	CBranch* pBranch;
	nIndex=nIndex+m_nDNetInfo.nBranch+m_nDNetInfo.nCable;
	if(!m_nBranchMap.Lookup(nIndex,pBranch))
	{
		pBranch=new CBranch;
		m_nBranchMap[nIndex]=pBranch;
		pBranch->AddTrans(PFaultWaste,VFault,PKong,
						KCurrent,STotal,GVoltage);

		pBranch->SetNode(head,tail);
		pBranch->SetBranchState(nIndex,state);
		pBranch->SetRatio(GVoltage,position);
		pBranch->m_nType=TRANS;
		pBranch->m_dP0TRANS=PKong;
		pBranch->m_CurrentTRANS=KCurrent;
		pBranch->m_SnTRANS=STotal;
		pBranch->m_VnTRANS=GVoltage;
		pBranch->m_wRB=pBranch->m_wR*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
		pBranch->m_wXB=pBranch->m_wX*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
		++m_nDNetInfo.nTransBranch;
	}
	pBranch->m_bHeadMark=0;
	pBranch->m_bTailMark=0;
	pBranch->m_bBranchMark=1;
	pBranch->m_wPHead=0;
	pBranch->m_wPTail=0;
	pBranch->m_wQHead=0;
	pBranch->m_wQTail=0;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nHeadNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nHeadNode;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nTailNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nTailNode;

}

void CDNet::SetCableRX(double CableArea,UINT sort,double VoltageGrade,double distance,
					   double& r,double& x,double& RB,double& XB)
{
	int mark;
	if(CableArea==10)mark=1;
	if(CableArea==16)mark=2;
	if(CableArea==25)mark=3;
	if(CableArea==35)mark=4;
	if(CableArea==50)mark=5;
	if(CableArea==70)mark=6;
	if(CableArea==95)mark=7;
	if(CableArea==120)mark=8;
	if(CableArea==150)mark=9;
	if(CableArea==185)mark=10;
	if(CableArea==240)mark=11;
	if(CableArea==300)mark=12;
	if(sort==0)
	{
		r=CableData[mark][1]*distance;
		x=CableData[mark][3]*distance;
		if(VoltageGrade==10.0)x=CableData[mark][4]*distance;
	}
	if(sort==1)
	{
		r=CableData[mark][2]*distance;
		x=CableData[mark][3]*distance;
		if(VoltageGrade==10.0)x=CableData[mark][4]*distance;
	}
	RB=r*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
	XB=x*m_nDNetInfo.wSB/(m_nDNetInfo.wVB*m_nDNetInfo.wVB);
		
}
void CDNet::SetCable(UINT nIndex,BOOL state,UINT head,UINT tail,double CableArea,
					 UINT sort,double VoltageGrade,double distance)
{
	CBranch* pBranch;
	double r=0,x=0,RB=0,XB=0;
	nIndex=nIndex+m_nDNetInfo.nBranch+m_nDNetInfo.nTransBranch;
	if(!m_nBranchMap.Lookup(nIndex,pBranch))
	{
		pBranch=new CBranch;
		m_nBranchMap[nIndex]=pBranch;
		++m_nDNetInfo.nCable;
		SetCableRX(CableArea,sort,VoltageGrade,distance,r,x,RB,XB);
		pBranch->m_nType=BRANCH;
		pBranch->SetRX(r,x,RB,XB);
		pBranch->SetNode(head,tail);
		pBranch->SetBranchState(nIndex,state);
	}
	pBranch->m_bHeadMark=0;
	pBranch->m_bTailMark=0;
	pBranch->m_bBranchMark=1;
	pBranch->m_wPHead=0;
	pBranch->m_wPTail=0;
	pBranch->m_wQHead=0;
	pBranch->m_wQTail=0;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nHeadNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nHeadNode;
	if(m_nDNetInfo.nMaxElement<pBranch->m_nTailNode)
		m_nDNetInfo.nMaxElement=pBranch->m_nTailNode;
}
void CDNet::SetBeginInfo(INT nIndex,INT nNode,double wP,double wQ)
{
	CBeginInfo* pBeginInfo;
	if(!m_nBeginInfoMap.Lookup(nIndex,pBeginInfo))
	{
		pBeginInfo=new CBeginInfo;
		m_nBeginInfoMap[nIndex]=pBeginInfo;
		pBeginInfo->m_nLoadIndex=nNode;
		pBeginInfo->m_nLoadNode=nNode;
		pBeginInfo->m_wPLoad=wP;
		pBeginInfo->m_wQLoad=wQ;
		++m_nDNetInfo.nLoad;
	}
	if(m_nDNetInfo.nMaxElement<pBeginInfo->m_nLoadIndex)
		m_nDNetInfo.nMaxElement=pBeginInfo->m_nLoadIndex;
}



void CDNet::SetSwitch(UINT nIndex,UINT head,UINT tail)
{
	CSwitch* pSwitch;
	if(!m_nSwitchMap.Lookup(nIndex,pSwitch))
	{
		pSwitch=new CSwitch;
		m_nSwitchMap[nIndex]=pSwitch;
		pSwitch->nHeadElement=head;
		pSwitch->nTailElement=tail;
		++m_nDNetInfo.nSwitch;
	}
	if(m_nDNetInfo.nMaxElement<pSwitch->nHeadElement)
		m_nDNetInfo.nMaxElement=pSwitch->nHeadElement;
	if(m_nDNetInfo.nMaxElement<pSwitch->nTailElement)
		m_nDNetInfo.nMaxElement=pSwitch->nTailElement;
}

void CDNet::SetSwitchState(UINT nIndex,BOOL state)
{
	CSwitch* pSwitch;
	if(m_nSwitchMap.Lookup(nIndex,pSwitch))
	{
		if(pSwitch->bState!=state)
		{
			pSwitch->bState=state;
			m_nDNetInfo.bNetChange=TRUE;
		}
	}
}


void CDNet::SetCapInfo(UINT nIndex,UINT node,double dP,double Sn,double Vn)
{
	CCapCompensation* pCapCom;
	if(!m_nCapMap.Lookup(nIndex,pCapCom))
	{
		pCapCom=new CCapCompensation;
		m_nCapMap[nIndex]=pCapCom;
		pCapCom->m_nElement=node;
		pCapCom->m_nCNode=node;
		pCapCom->m_dPc=dP;
		pCapCom->m_SnPower=Sn;
		pCapCom->m_Vn=Vn;
		++m_nDNetInfo.nCap;
	}
	if(m_nDNetInfo.nMaxElement<pCapCom->m_nElement)
		m_nDNetInfo.nMaxElement=pCapCom->m_nElement;
}

////////////////////////////////////////
///CDNet Set
/////////////////////////////////////////
void CDNet::SetSB(double SBvalue,double VBvalue)
{
	m_nDNetInfo.wSB=SBvalue;
	m_nDNetInfo.wVB=VBvalue;
}

void CDNet::SetFeederMumber(int number)
{
	m_nDNetInfo.nFeederRoot=number;
	//初始化溃线数组
	m_nFeederRoot.SetSize(number+1);
	m_nNewFeederRoot.SetSize(number+1);
	m_nFeederVoltage.SetSize(number+1);
}

void CDNet::SetVoltageConergence(double value)
{
	m_nDNetInfo.wVoltageConvergence=value;
}

void CDNet::SetPowerConvergence(double value)
{
	m_nDNetInfo.wPConvergence=m_nDNetInfo.wQConvergence=value;
}

void CDNet::SetMark(BOOL mark)
{
	m_nDNetInfo.m_bMark=mark;
}

void CDNet::SetIterstion(int value)
{
	if(value<5)return;
	m_nDNetInfo.nMaxIteration=value;
}

///////////////////////////////////////////
///operation
////////////////////////////////////////////
void CDNet::NetAnalyse()
{
	//todo code
	m_nSwitchLinkMap.SetSize(m_nDNetInfo.nMaxElement+1);
	m_nMaxElementArray.SetSize(m_nDNetInfo.nMaxElement+1);
	//初始化元件数组
	m_nDNetInfo.nBranch+=m_nDNetInfo.nCable+m_nDNetInfo.nTransBranch;
	m_nDNetInfo.nTBranch=m_nDNetInfo.nBranch;
	for(UINT i=0;i<=m_nDNetInfo.nMaxElement;++i)
		m_nMaxElementArray[i]=-1;

	for(POSITION pos=m_nSwitchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CSwitch* pSwitch=new CSwitch;
		CLink* pLink=new CLink;
		CLink* pLink1=new CLink;
		m_nSwitchMap.GetNextAssoc(pos,key,pSwitch);
		m_nMaxElementArray[pSwitch->nHeadElement]=0;
		m_nMaxElementArray[pSwitch->nTailElement]=0;
		pLink->nNode=pSwitch->nTailElement;
		pLink->bState=pSwitch->bState;
		m_nSwitchLinkMap[pSwitch->nHeadElement].SetAt(key,pLink);
		pLink1->nNode=pSwitch->nHeadElement;
		pLink1->bState=pSwitch->bState;
		m_nSwitchLinkMap[pSwitch->nTailElement].SetAt(key,pLink1);

	}



	for(pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		CLink* pLink=new CLink;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		m_nMaxElementArray[pBranch->m_nHeadElement]=0;
		m_nMaxElementArray[pBranch->m_nTailElement]=0;
	}
	//划分节点
	if(m_nDNetInfo.bNetChange)
	{
		m_nDNetInfo.nNode=0;
		m_nDNetInfo.bNetChange=FALSE;

		for(i=1;i<=m_nDNetInfo.nMaxElement;++i)
		{
			if(m_nMaxElementArray[i]==0)
			{
				m_nMaxElementArray[i]=++m_nDNetInfo.nNode;
				DeepthFirstSearch(i);
			}
		}
	}

	//导出各支路的头尾节点