dnet.cpp

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

	for(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];
	}
	//导出负荷节点号
	for(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];
	}
	//导出溃线根节点号
	for(int j=1;j<=m_nDNetInfo.nFeederRoot;++j)
		m_nNewFeederRoot[j]=m_nMaxElementArray[m_nFeederRoot[j]];                                                                         
	//导出电容的节点号
	for(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];
	}
	m_nNodeSubSystem.SetSize(m_nDNetInfo.nNode+1);
	m_nBranchSubSystem.SetSize(m_nDNetInfo.nTBranch+1);
	m_nBranchLinkMap.SetSize(m_nDNetInfo.nNode+1);

	//初始化上述数组
	for(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(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);
		}
	}

	//支路划分子系统
	for(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::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;
			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
////////////////////////////////////////////
BOOL CDNet::DNetInitialization()
{
	INT nNode=1;
	CArray<INT,INT> m_nTranKey;
	CArray<INT,INT> nBranchAtNode;//节点出线数数组
	nBranchAtNode.SetSize(m_nDNetInfo.nNode+1);
	m_nBranchKey.SetSize(m_nDNetInfo.nBranch+1);

	//建立变压器与负荷的关联表
	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;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBegin);
		for(POSITION pos1=m_nBranchMap.GetStartPosition();pos1!=NULL;)
		{
			UINT key1=0;
			CBranch* pBranch;
			m_nBranchMap.GetNextAssoc(pos1,key1,pBranch);
			if(pBranch->m_nType==TRANS&&pBranch->m_nTailNode==pBegin->m_nLoadNode)
			{
				m_nTranKey[key]=key1;
				break;
			}
		}
	}
	//初始化节点出线数数组
	for(i=0;i<=m_nDNetInfo.nNode;++i)
		nBranchAtNode[i]=0;

	//统计各节点的出线数
	int RunBranch=0;

	for(pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		if(!(IsOnSystem(pBranch->m_nHeadNode)&&
			IsOnSystem(pBranch->m_nTailNode)))	continue;
		if(pBranch->m_bState)
		{
			++nBranchAtNode[pBranch->m_nHeadNode];
			++nBranchAtNode[pBranch->m_nTailNode];
			++RunBranch;
		}
	}
	
	//给节点电压赋值
	m_nNodeArray.SetSize(m_nDNetInfo.nNode+1);
	for(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==UINT(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;
		m_nNodeArray[i].wP=0;
		m_nNodeArray[i].wQ=0;

	}
	
	for(pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBeginInfo* pBeginInfo=new CBeginInfo;
		m_nBeginInfoMap.GetNextAssoc(pos,key,pBeginInfo);
		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);
		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);
	}
	
	/////////////////////////////////////////
	//初始化网络

	i=0;
	
	while(nNode<=RunBranch)
	{
		++i;
		if(i>m_nDNetInfo.nNode) i=1;
		//是否为环网
		BOOL LP=FALSE;
		for(INT k=1;k<=m_nDNetInfo.nNode;++k)
		{
			if(!IsOnSystem(k)) continue;
			BOOL LQ=FALSE;
			for(INT m=1;m<=m_nDNetInfo.nFeederRoot;++m)
			{
				if(m_nNewFeederRoot[m]==UINT(k))
				{
					LQ=TRUE;
					break;
				}
			}
			if(LQ) continue;
			if(nBranchAtNode[k]==1)
			{
				LP=TRUE;
				break;
			}
		}
		if(!LP)	return FALSE;
		if(nBranchAtNode[i]==1)
		{
			for(pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
			{
				UINT key=0;
				CBranch* pBranch=new CBranch;
				m_nBranchMap.GetNextAssoc(pos,key,pBranch);
				if(!(IsOnSystem(pBranch->m_nHeadNode)&&
					IsOnSystem(pBranch->m_nTailNode))) continue;
				if(pBranch->m_bState&&nBranchAtNode[pBranch->m_nHeadNode]!=0&&nBranchAtNode[pBranch->m_nTailNode]!=0
					&&(pBranch->m_nHeadNode==UINT(i)||pBranch->m_nTailNode==UINT(i)))
				{
					BOOL bMark1=TRUE;
					BOOL bMark2=TRUE;
					for(int j=1;j<=m_nDNetInfo.nFeederRoot;++j)
					{
						if(pBranch->m_nHeadNode==m_nNewFeederRoot[j]) bMark1=FALSE;
						if(pBranch->m_nTailNode==m_nNewFeederRoot[j]) bMark2=FALSE;
					}
					if((nBranchAtNode[pBranch->m_nHeadNode]==1&&bMark1)
						||(nBranchAtNode[pBranch->m_nTailNode]==1&&bMark2)) 
					{
						m_nBranchKey[nNode]=key;
						++nNode;
					}                                                                

					if(nBranchAtNode[pBranch->m_nHeadNode]==1&&bMark1)
					{
						nBranchAtNode[pBranch->m_nHeadNode]=0;
						pBranch->m_bHeadMark=1;
						if(m_nDNetInfo.m_bMark)
						{
							if(pBranch->m_nType==BRANCH)
							{
								pBranch->m_wPHead=m_nNodeArray[pBranch->m_nHeadNode].wP;
								pBranch->m_wQHead=m_nNodeArray[pBranch->m_nHeadNode].wQ;

								//计算另一头功率
								pBranch->m_wPTail=pBranch->m_wPHead+((pBranch->m_wPHead*pBranch->m_wPHead+
									pBranch->m_wQHead*pBranch->m_wQHead)/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
									m_nNodeArray[pBranch->m_nHeadNode].wVoltage))*pBranch->m_wR;

								pBranch->m_wQTail=pBranch->m_wQHead+((pBranch->m_wPHead*pBranch->m_wPHead+
									pBranch->m_wQHead*pBranch->m_wQHead)/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
									m_nNodeArray[pBranch->m_nHeadNode].wVoltage))*pBranch->m_wX;
							
								
								//修改节点功率
								m_nNodeArray[pBranch->m_nTailNode].wP+=pBranch->m_wPTail;
								m_nNodeArray[pBranch->m_nTailNode].wQ+=pBranch->m_wQTail;
							}
						}
						else
						{
							//标吆值
							if(pBranch->m_nType==BRANCH)
							{
								pBranch->m_wPHead=m_nNodeArray[pBranch->m_nHeadNode].wP;
								pBranch->m_wQHead=m_nNodeArray[pBranch->m_nHeadNode].wQ;

								//计算另一头功率
								pBranch->m_wPTail=pBranch->m_wPHead+((pBranch->m_wPHead*pBranch->m_wPHead+
									pBranch->m_wQHead*pBranch->m_wQHead)/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
									m_nNodeArray[pBranch->m_nHeadNode].wVoltage))*pBranch->m_wRB;

								pBranch->m_wQTail=pBranch->m_wQHead+((pBranch->m_wPHead*pBranch->m_wPHead+
									pBranch->m_wQHead*pBranch->m_wQHead)/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
									m_nNodeArray[pBranch->m_nHeadNode].wVoltage))*pBranch->m_wXB;
							
								
								//修改节点功率
								m_nNodeArray[pBranch->m_nTailNode].wP+=pBranch->m_wPTail;
								m_nNodeArray[pBranch->m_nTailNode].wQ+=pBranch->m_wQTail;
							}
						}

						nBranchAtNode[pBranch->m_nTailNode]-=1;
						break;
					}
					if(nBranchAtNode[pBranch->m_nTailNode]==1&&bMark2)
					{
						double wPT=0,wQT=0;
						double wVT,wVH;
						nBranchAtNode[pBranch->m_nTailNode]=0;
						pBranch->m_bTailMark=1;
						if(m_nDNetInfo.m_bMark)//采用有名值计算
						{
							if(pBranch->m_nType==BRANCH)
							{
								wVT=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
								wPT=pBranch->m_wPTail=m_nNodeArray[pBranch->m_nTailNode].wP;
								wQT=pBranch->m_wQTail=m_nNodeArray[pBranch->m_nTailNode].wQ;
								pBranch->m_wPHead=wPT+(wPT*wPT+wQT*wQT)*pBranch->m_wR/(wVT*wVT);
								pBranch->m_wQHead=wQT+(wPT*wPT+wQT*wQT)*pBranch->m_wX/(wVT*wVT);
								m_nNodeArray[pBranch->m_nHeadNode].wP+=pBranch->m_wPHead;
								m_nNodeArray[pBranch->m_nHeadNode].wQ+=pBranch->m_wQHead;
							}
							else
							{
								//Add Code
								wVT=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
								wVH=m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
								wPT=pBranch->m_wPTail=m_nNodeArray[pBranch->m_nTailNode].wP;
								wQT=pBranch->m_wQTail=m_nNodeArray[pBranch->m_nTailNode].wQ;
								pBranch->m_wPHead=wPT+(wPT*wPT+wQT*wQT)*pBranch->m_wR/(wVT*pBranch->m_wRatio*wVT*pBranch->m_wRatio)
									+pBranch->m_dP0TRANS*wVH*wVH*(1e-3)/(pBranch->m_VnTRANS*pBranch->m_VnTRANS);
								pBranch->m_wQHead=wQT+(wPT*wPT+wQT*wQT)*pBranch->m_wX/(wVT*pBranch->m_wRatio*wVT*pBranch->m_wRatio)
									+0.01*pBranch->m_SnTRANS*pBranch->m_CurrentTRANS*wVH*wVH*(1e-3)/(pBranch->m_VnTRANS*pBranch->m_VnTRANS);
								m_nNodeArray[pBranch->m_nHeadNode].wP+=pBranch->m_wPHead;
								m_nNodeArray[pBranch->m_nHeadNode].wQ+=pBranch->m_wQHead;
							}
						}
						else  //采用标吆值
						{
							//Add Code
							if(pBranch->m_nType==BRANCH)
							{
								wVT=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
								wPT=pBranch->m_wPTail=m_nNodeArray[pBranch->m_nTailNode].wP;
								wQT=pBranch->m_wQTail=m_nNodeArray[pBranch->m_nTailNode].wQ;
								pBranch->m_wPHead=wPT+(wPT*wPT+wQT*wQT)*pBranch->m_wRB/(wVT*wVT);
								pBranch->m_wQHead=wQT+(wPT*wPT+wQT*wQT)*pBranch->m_wXB/(wVT*wVT);
								m_nNodeArray[pBranch->m_nHeadNode].wP+=pBranch->m_wPHead;
								m_nNodeArray[pBranch->m_nHeadNode].wQ+=pBranch->m_wQHead;
							}
							else
							{
								//Add Code
								wVT=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
								wVH=m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
								wPT=pBranch->m_wPTail=m_nNodeArray[pBranch->m_nTailNode].wP;
								wQT=pBranch->m_wQTail=m_nNodeArray[pBranch->m_nTailNode].wQ;
								pBranch->m_wPHead=wPT+(wPT*wPT+wQT*wQT)*pBranch->m_wRB/(wVT*pBranch->m_wRatio*wVT*pBranch->m_wRatio)
									+pBranch->m_dP0TRANS*wVH*wVH*m_nDNetInfo.wVB*m_nDNetInfo.wVB/(pBranch->m_VnTRANS*pBranch->m_VnTRANS*m_nDNetInfo.wSB);
								pBranch->m_wQHead=wQT+(wPT*wPT+wQT*wQT)*pBranch->m_wXB/(wVT*pBranch->m_wRatio*wVT*pBranch->m_wRatio)
									+0.01*pBranch->m_SnTRANS*pBranch->m_CurrentTRANS*wVH*wVH*m_nDNetInfo.wVB*m_nDNetInfo.wVB/(pBranch->m_VnTRANS*pBranch->m_VnTRANS*m_nDNetInfo.wSB);
								m_nNodeArray[pBranch->m_nHeadNode].wP+=pBranch->m_wPHead;
								m_nNodeArray[pBranch->m_nHeadNode].wQ+=pBranch->m_wQHead;
							}
						}
						nBranchAtNode[pBranch->m_nHeadNode]-=1;
						break;
					}

				if(pBranch->m_nHeadNode==UINT(i)||pBranch->m_nTailNode==UINT(i)) break;
				}
			}//end for
		}//end if

	}//edn while
	m_nDNetInfo.nBranch=nNode-1;

	return TRUE;
}//end


/////////////////////////////
//DNet load flow
//////////////////////////////
BOOL CDNet::DistributionFlow()
{
	double wFirstNodeVoltage;//节点的前一次电压
	double dVB_N=0,dV;//电压差值
	CArray<int,int> nRootKeyAtBranch;//根节点所在支路号
	CArray<INT,INT> nNodeMark;

	nRootKeyAtBranch.SetSize(m_nDNetInfo.nFeederRoot+1);
	nNodeMark.SetSize(m_nDNetInfo.nNode+1);
	

	//查找根节点所在支路
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		for(int i=1;i<=m_nDNetInfo.nFeederRoot;++i)
			if(pBranch->m_nHeadNode==m_nNewFeederRoot[i]||
				pBranch->m_nTailNode==m_nNewFeederRoot[i])
				nRootKeyAtBranch.SetAt(i,key);
	}

	//统计计算支路数

	int nFeedBranch=0;
	for(int i=1;i<=m_nDNetInfo.nFeederRoot;++i)
	{
		for(pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
		{
			UINT key=0;
			CBranch* pBranch=new CBranch;
			m_nBranchMap.GetNextAssoc(pos,key,pBranch);
			if(m_nBranchSubSystem[key]==m_nNodeSubSystem[m_nNewFeederRoot[i]])
				++nFeedBranch;
		}
	}


	//回推各节点的电压,前推个节点功率
	for(int IT=1;IT<=m_nDNetInfo.nMaxIteration;++IT)
	{
		for(int k=1;k<=m_nDNetInfo.nNode;++k)
			nNodeMark[k]=0;
		dVB_N=0;
		//计算根支路
		for(int j=1;j<=m_nDNetInfo.nFeederRoot;++j)
		{
			CBranch* pBranch=new CBranch; 
			m_nBranchMap.Lookup(nRootKeyAtBranch[j],pBranch);
			if(pBranch->m_bState&&pBranch->m_nHeadNode==m_nNewFeederRoot[j]&&pBranch->m_bBranchMark)
			{
				pBranch->m_bBranchMark=0;
				m_nNodeArray[pBranch->m_nHeadNode].wVoltage=m_nFeederVoltage[j];
				wFirstNodeVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
				nNodeMark[pBranch->m_nTailNode]=1;
				if(m_nDNetInfo.m_bMark)
				{
					dV=(pBranch->m_wPHead*pBranch->m_wR+pBranch->m_wQHead*pBranch->m_wX)/m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
					m_nNodeArray[pBranch->m_nTailNode].wVoltage=m_nNodeArray[pBranch->m_nHeadNode].wVoltage-dV;
					if(dVB_N<fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage))
						dVB_N=fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage);
				}
				else
					//用标吆值
				{
					dV=(pBranch->m_wPHead*pBranch->m_wRB+pBranch->m_wQHead*pBranch->m_wXB)/m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
					m_nNodeArray[pBranch->m_nTailNode].wVoltage=m_nNodeArray[pBranch->m_nHeadNode].wVoltage-dV;
					if(dVB_N<fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage))
						dVB_N=fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage);
				}

			}