dnet.cpp

这是一个简单测试电力系统潮流计算DLL的源代码

		for(i=1;i<=m_nDNetInfo.nMaxElement;++i)
		{
			if(m_nMaxElementArray[i]==0)
			{
				m_nMaxElementArray[i]=++m_nDNetInfo.nNode;
//				TRACE("%d	%d\n",i,m_nDNetInfo.nNode);
				DeepthFirstSearch(i);
			}
		}
	}
}

void CDNet::BranchAtNode()
{
	//导出各支路的头尾节点
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		pBranch->m_nHeadNode=m_nMaxElementArray[pBranch->m_nHeadElement];
		pBranch->m_nTailNode=m_nMaxElementArray[pBranch->m_nTailElement];
	}
}
void CDNet::LoadAtNode()
{
	//导出负荷节点号
	for(POSITION pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBeginInfo* pBeginInfo=new CBeginInfo;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBeginInfo);
		pBeginInfo->m_nLoadNode=m_nMaxElementArray[pBeginInfo->m_nLoadIndex];
	}
}
void CDNet::FeederAtNode()
{
//导出溃线根节点号
	for(POSITION pos=m_nFeederMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CFeeder* pFeeder=new CFeeder;
		m_nFeederMap.GetNextAssoc(pos,key,pFeeder);
		pFeeder->nNode=m_nMaxElementArray[pFeeder->nElement];
	}
}
void CDNet::CapAtNode()
{
	//导出电容的节点号
	for(POSITION pos=m_nCapMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CCapCompensation* pCapCom=new CCapCompensation;
		m_nCapMap.GetNextAssoc(pos,key,pCapCom);
		pCapCom->m_nCNode=m_nMaxElementArray[pCapCom->m_nElement];
	}
}
void CDNet::EleToNode()
{
	BranchAtNode();//导出各支路的头尾节点
	LoadAtNode();//导出负荷节点号
	FeederAtNode();//导出溃线根节点号
	CapAtNode();//导出电容的节点号
}
void CDNet::CreateNodeSubSys()
{
	//初始化上述数组
	for(int i=1;i<=(UINT)m_nDNetInfo.nNode;++i)
		m_nNodeSubSystem[i]=-1;

	for(i=1;i<=(UINT)m_nDNetInfo.nTBranch;++i)
		m_nBranchSubSystem[i]=0;

	//节点划分子系统
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		CLink* pLink=new CLink;
		CLink* pLink1=new CLink;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		m_nNodeSubSystem[pBranch->m_nHeadNode]=m_nNodeSubSystem[pBranch->m_nTailNode]=0;
		pLink->nNode=pBranch->m_nTailNode;
		pLink->bState=pBranch->m_bState;
		m_nBranchLinkMap[pBranch->m_nHeadNode].SetAt(key,pLink);
		pLink1->nNode=pBranch->m_nHeadNode;
		pLink1->bState=pBranch->m_bState;
		m_nBranchLinkMap[pBranch->m_nTailNode].SetAt(key,pLink1);
	}


	for(i=1;i<=(UINT)m_nDNetInfo.nNode;++i)
	{
		if(m_nNodeSubSystem[i]==0)
		{
			m_nNodeSubSystem[i]=++m_nDNetInfo.nSubSystem;
//			TRACE("%d	%d\n",i,m_nDNetInfo.nSubSystem);
			DeepthFirstSearch1(i);
		}
	}
}

void CDNet::CreateBranchSubSys()
{
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		if(pBranch->m_bState)
		{
			m_nBranchSubSystem[key]=m_nNodeSubSystem[pBranch->m_nHeadNode];
		}
	}
}
void CDNet::NetAnalyse0()
{
	//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;

	CreateNodeEle();//建立元件节点关联表
	EleToNode();	//将系统中的元件号转化为节点号

	m_nNodeSubSystem.SetSize(m_nDNetInfo.nNode+1);
	m_nBranchSubSystem.SetSize(m_nDNetInfo.nTBranch+1);
	m_nBranchLinkMap.SetSize(m_nDNetInfo.nNode+1);

	CreateNodeSubSys();//划分节点子系统
	CreateBranchSubSys();//支路划分子系统
}

void CDNet::DeepthFirstSearch(int i)
{

	for(POSITION pos=m_nSwitchLinkMap[i].GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CLink* pLink=new CLink;
		m_nSwitchLinkMap[i].GetNextAssoc(pos,key,pLink);
		if(m_nMaxElementArray[pLink->nNode]==0&&pLink->bState)
		{
			m_nMaxElementArray[pLink->nNode]=m_nDNetInfo.nNode;
//			TRACE("%d	%d\n",pLink->nNode,m_nDNetInfo.nNode);
			DeepthFirstSearch(pLink->nNode);
		}
	}
}
void CDNet::DeepthFirstSearch1(int i)
{

	for(POSITION pos=m_nBranchLinkMap[i].GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CLink* pLink=new CLink;
		m_nBranchLinkMap[i].GetNextAssoc(pos,key,pLink);
		if(m_nNodeSubSystem[pLink->nNode]==0&&pLink->bState)
		{
			m_nNodeSubSystem[pLink->nNode]=m_nDNetInfo.nSubSystem;
//			TRACE("%d	%d\n",pLink->nNode,m_nDNetInfo.nSubSystem);
			DeepthFirstSearch1(pLink->nNode);
		}
	}
}


////////////////////////////////////////////
//DNet COMputer
////////////////////////////////////////////

void CDNet::CreateLoadVsTrans()
{
	m_nTranKey.SetSize(m_nDNetInfo.nLoad+1);
	for(INT i=1;i<=m_nDNetInfo.nLoad;++i)
		m_nTranKey[i]=0;
 	for(POSITION pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBeginInfo* pBegin=new CBeginInfo;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBegin);
		if(!pBegin->bType)  continue;
		for(POSITION pos1=m_nBranchMap.GetStartPosition();pos1!=NULL;)
		{
			UINT key1=0;
			CBranch* pBranch=new CBranch;
			m_nBranchMap.GetNextAssoc(pos1,key1,pBranch);
			if(pBranch->m_nType==TRANS&&pBranch->m_nTailNode==pBegin->m_nLoadNode)
			{
				m_nTranKey[pBegin->nOrder]=key1;
//				TRACE("%d	%d\n",pBegin->nOrder,key1);
				break;
			}
		}
	}
}
void CDNet::ReSetEnergy()
{
	CArray< INT ,INT >  TransKey;
	TransKey.SetSize(m_nDNetInfo.nTransBranch+1);


	CreateLoadVsTrans();//变压器与负荷关联

	CArray<INT,INT> m_nLoadSub;
	m_nLoadSub.SetSize(m_nDNetInfo.nLoad+1);
	CArray<INT,INT> m_nLoadState;
	m_nLoadState.SetSize(m_nDNetInfo.nLoad+1);
	for(POSITION pos=m_nFeederMap.GetStartPosition();pos!=NULL;)
	{
		INT nLoadAtSubSys=0;
		bool bTrue=TRUE;
		double SnTotal=0;
		double SnTotal1=0;
		UINT key=0;
		CFeeder* pFeeder;
		m_nFeederMap.GetNextAssoc(pos,key,pFeeder);
		INT nSystem=m_nNodeSubSystem[pFeeder->nNode];
		double wP=0,wQ=0;
		for(POSITION pos1=m_nBeginInfoMap.GetStartPosition();pos1!=NULL;)
		{
			UINT key1=0;
			CBeginInfo* pBegin;
			m_nBeginInfoMap.GetNextAssoc(pos1,key1,pBegin);
			INT nSystem1=m_nNodeSubSystem[pBegin->m_nLoadNode];
			if(m_nTranKey[key1]==0)	
			{
				wP+=pBegin->m_AP;
				wQ+=pBegin->m_AQ;
				continue;
			}
			if(nSystem==nSystem1)
			{
				m_nLoadSub[++nLoadAtSubSys]=key1;
				m_nLoadState[nLoadAtSubSys]=TRUE;
				if(pBegin->bType&&(pBegin->m_AP<0||pBegin->m_AQ<0))
				{
					bTrue=FALSE;
					m_nLoadState[nLoadAtSubSys]=FALSE;
					CBranch* pBranch;
					m_nBranchMap.Lookup(m_nTranKey[key1],pBranch);
					SnTotal+=pBranch->m_SnTRANS;
				}
				else
				{
					wP+=pBegin->m_AP;
					wQ+=pBegin->m_AQ;
					CBranch* pBranch;
					m_nBranchMap.Lookup(m_nTranKey[key1],pBranch);
					SnTotal1+=pBranch->m_SnTRANS;
				}
			}
		}
		INT i;
		double valueP=pFeeder->wMeasureAP-pFeeder->wConvergenceP-wP;
		double valueQ=pFeeder->wMeasureAQ-pFeeder->wConvergenceQ-wQ;
		switch(bTrue)
		{
			case 0:
				for(i=1;i<=nLoadAtSubSys;++i)
				{
					if(!m_nLoadState[i])
					{
						CBranch* pBranch;
						m_nBranchMap.Lookup(m_nTranKey[m_nLoadSub[i]],pBranch);
						CBeginInfo* pBegin;
						m_nBeginInfoMap.Lookup(m_nLoadSub[i],pBegin);
						pBegin->m_AP=valueP*pBranch->m_SnTRANS/SnTotal;
						pBegin->m_AQ=valueQ*pBranch->m_SnTRANS/SnTotal;
					}
				}
				break;
			case 1:
				for(i=1;i<=nLoadAtSubSys;++i)
				{
					if(m_nTranKey[i]==0)
					{
						i--;
						continue;
					}
					CBranch* pBranch;
					m_nBranchMap.Lookup(m_nTranKey[m_nLoadSub[i]],pBranch);
					CBeginInfo* pBegin;
					m_nBeginInfoMap.Lookup(m_nLoadSub[i],pBegin);
					pBegin->m_AP+=valueP*pBranch->m_SnTRANS/SnTotal1;
					pBegin->m_AQ+=valueQ*pBranch->m_SnTRANS/SnTotal1;
				}
				break;
		}
	}
}

void CDNet::EnergyToPower()
{
	for(POSITION pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBeginInfo* pBegin;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBegin);
		pBegin->m_wPLoad=(1e-3)*pBegin->m_PK*pBegin->m_AP/m_nDNetInfo.wRuntime;
		pBegin->m_wQLoad=(1e-3)*pBegin->m_QL*pBegin->m_AQ/m_nDNetInfo.wRuntime;
//		TRACE("%d	%f	%f\n",key,pBegin->m_wPLoad,pBegin->m_wQLoad);
	}
}

void CDNet::IndexOption()
{
	CArray<INT,INT> nBranchAtNode;//节点出线数数组
	nBranchAtNode.SetSize(m_nDNetInfo.nNode+1);
	m_nNewIndex.SetSize(m_nDNetInfo.nNode+1);
	m_nOldIndex.SetSize(m_nDNetInfo.nNode+1);

	//初始化节点出线数数组
	for(int i=0;i<=m_nDNetInfo.nNode;++i)
		nBranchAtNode[i]=0;

	//统计各节点的出线数
	int RunBranch=0;
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		++nBranchAtNode[pBranch->m_nHeadNode];
		++nBranchAtNode[pBranch->m_nTailNode];
		++RunBranch;
	}
	//编号
	INT nNode=0;
	while(nNode<(m_nDNetInfo.nNode-m_nDNetInfo.nFeederRoot))
	{
		for(INT i=1;i<=m_nDNetInfo.nNode;++i)
		{
			bool bTrue=TRUE;
			for(int j=1;j<=m_nDNetInfo.nFeederRoot;++j)
			{
				CFeeder* pFeeder;
				m_nFeederMap.Lookup(j,pFeeder);
				if(pFeeder->nNode==i)
				{
					bTrue=FALSE;
					break;
				}
			}
			if(!bTrue)	continue;
			if(nBranchAtNode[i]==1) 
			{
				m_nNewIndex[++nNode]=i;
				TRACE("%d	%d\n",nNode,i);
				m_nOldIndex[i]=nNode;
				nBranchAtNode[i]=0;
				for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
				{
					UINT key=0;
					CBranch* pBranch;
					m_nBranchMap.GetNextAssoc(pos,key,pBranch);
					if(pBranch->m_nTailNode==i&&nBranchAtNode[pBranch->m_nHeadNode]!=0)
					{
						--nBranchAtNode[pBranch->m_nHeadNode];
						break;
					}
					if(pBranch->m_nHeadNode==i&&nBranchAtNode[pBranch->m_nTailNode]!=0)
					{
						--nBranchAtNode[pBranch->m_nTailNode];
						break;
					}
				}
			}
		}
	}
	for(int j=1;j<=m_nDNetInfo.nFeederRoot;++j)
	{
		CFeeder* pFeeder;
		m_nFeederMap.Lookup(j,pFeeder);
		m_nNewIndex[++nNode]=pFeeder->nNode;
//		TRACE("%d	%d\n",nNode,pFeeder->nNode);
		m_nOldIndex[pFeeder->nNode]=nNode;
	}
}
void CDNet::ModifyPower0(INT nIndex)
{
	CFeeder* pFeeder;
	m_nFeederMap.Lookup(nIndex,pFeeder);
	INT system=m_nNodeSubSystem[pFeeder->nNode];
	for(INT i=1;i<=m_nDNetInfo.nNode;++i)
	{
		if(m_nNodeSubSystem[i]==system)
		{
			m_nNodeArray[i].wP=0;
			m_nNodeArray[i].wQ=0;
		}

	}
	for(POSITION pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBeginInfo* pBeginInfo=new CBeginInfo;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBeginInfo);
		if(m_nNodeSubSystem[pBeginInfo->m_nLoadNode]==system)
		{
			m_nNodeArray[pBeginInfo->m_nLoadNode].wP=pBeginInfo->m_wPLoad;
			m_nNodeArray[pBeginInfo->m_nLoadNode].wQ=pBeginInfo->m_wQLoad;
		}
	}
	for(pos=m_nCapMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CCapCompensation* pCapCom=new CCapCompensation;
		m_nCapMap.GetNextAssoc(pos,key,pCapCom);
		if(m_nNodeSubSystem[pCapCom->m_nCNode]==system)
		{
			m_nNodeArray[pCapCom->m_nCNode].wP+=-pCapCom->m_dPc*m_nNodeArray[pCapCom->m_nCNode].wVoltage*
				m_nNodeArray[pCapCom->m_nCNode].wVoltage/(pCapCom->m_Vn*pCapCom->m_Vn);
			m_nNodeArray[pCapCom->m_nCNode].wQ+=-pCapCom->m_SnPower*m_nNodeArray[pCapCom->m_nCNode].wVoltage*
				m_nNodeArray[pCapCom->m_nCNode].wVoltage/(pCapCom->m_Vn*pCapCom->m_Vn);
		}
	}
}
void CDNet::ModifyNode()
{
	for(INT i=1;i<=m_nDNetInfo.nNode;++i)
	{
		m_nNodeArray[i].wVoltage=m_nDNetInfo.wVB;
		for(POSITION pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
		{
			UINT key=0;
			CBeginInfo* pBeginInfo=new CBeginInfo;
			m_nBeginInfoMap.GetNextAssoc(pos,key,pBeginInfo);
			if(pBeginInfo->m_nLoadNode==i)
			{
				if(m_nTranKey[key])
					m_nNodeArray[i].wVoltage=0.4;
				break;
			}
		}
		if(!m_nDNetInfo.m_bMark) m_nNodeArray[i].wVoltage=1.0;
		m_nNodeArray[i].wRadian=0;
	}
}
void CDNet::DNetInitialize()
{
	m_nNodeArray.SetSize(m_nDNetInfo.nNode+1);
	ReSetEnergy();
	EnergyToPower();
	IndexOption();
	ModifyNode();
}

void CDNet::GetPower(INT nIndex)
{
	CFeeder* pFeeder;
	m_nFeederMap.Lookup(nIndex,pFeeder);
	INT system=m_nNodeSubSystem[pFeeder->nNode];
	for(INT i=1;i<=m_nDNetInfo.nNode;++i)