dnet.cpp

这是一个简单电网结构分析计算的源代码

	{
		if(m_nNodeSubSystem[m_nNewIndex[i]]==system)
		{
			CBranch* pBranch;
			for(int k=1;k<=m_nDNetInfo.nBranch;++k)
			{
				if(m_nBranchSubSystem[k]!=system)	continue;
				m_nBranchMap.Lookup(k,pBranch);
				if((m_nNewIndex[i]==pBranch->m_nTailNode&&m_nOldIndex[pBranch->m_nHeadNode]>i)
					||(m_nNewIndex[i]==pBranch->m_nHeadNode&&m_nOldIndex[pBranch->m_nTailNode]>i)) break;
			}
			if(!pBranch->m_bState)	continue;
			//计算之路节点功率
			if(m_nDNetInfo.m_bMark)
			{
				if(m_nDNetInfo.m_bMark)//采用有名值计算
				{
					if(m_nNewIndex[i]==pBranch->m_nHeadNode)
					{
						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)*pBranch->m_wR/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
							m_nNodeArray[pBranch->m_nHeadNode].wVoltage);
						pBranch->m_wQTail=pBranch->m_wQHead+(pBranch->m_wPHead*pBranch->m_wPHead+
							pBranch->m_wQHead*pBranch->m_wQHead)*pBranch->m_wX/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
							m_nNodeArray[pBranch->m_nHeadNode].wVoltage);
						/////////
						m_nNodeArray[pBranch->m_nTailNode].wP+=pBranch->m_wPTail;
						m_nNodeArray[pBranch->m_nTailNode].wQ+=pBranch->m_wQTail;
					}
					if(m_nNewIndex[i]==pBranch->m_nTailNode)
					{
						double wPT=0,wQT=0;
						double wVT,wVH;
						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(m_nNewIndex[i]==pBranch->m_nHeadNode)
				{
					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)*pBranch->m_wRB/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
						m_nNodeArray[pBranch->m_nHeadNode].wVoltage);
					pBranch->m_wQTail=pBranch->m_wQHead+(pBranch->m_wPHead*pBranch->m_wPHead+
						pBranch->m_wQHead*pBranch->m_wQHead)*pBranch->m_wXB/(m_nNodeArray[pBranch->m_nHeadNode].wVoltage*
						m_nNodeArray[pBranch->m_nHeadNode].wVoltage);
					/////////
					m_nNodeArray[pBranch->m_nTailNode].wP+=pBranch->m_wPTail;
					m_nNodeArray[pBranch->m_nTailNode].wQ+=pBranch->m_wQTail;
				}
				if(m_nNewIndex[i]==pBranch->m_nTailNode)
				{
					double wPT=0,wQT=0;
					double wVT,wVH;
					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;
					}
				}
			}
		}
	}
}
double CDNet::GetVoltage(INT nIndex)
{
	double wFirstNodeVoltage;
	double dV,dVB_N;
	CFeeder* pFeeder;
	m_nFeederMap.Lookup(nIndex,pFeeder);
	INT system=m_nNodeSubSystem[pFeeder->nNode];
	for(INT i=m_nDNetInfo.nNode;i>=1;--i)
	{
		if(m_nNodeSubSystem[m_nNewIndex[i]]==system)
		{
			CBranch* pBranch;
			for(int k=1;k<=m_nDNetInfo.nBranch;++k)
			{
				if(m_nBranchSubSystem[k]!=system)	continue;
				m_nBranchMap.Lookup(k,pBranch);
				if((m_nNewIndex[i]==pBranch->m_nHeadNode&&m_nOldIndex[pBranch->m_nTailNode]<i)
					||(m_nNewIndex[i]==pBranch->m_nTailNode&&m_nOldIndex[pBranch->m_nHeadNode]<i)) 
				{
					//计算尾节点的电压
					if(!pBranch->m_bState)	continue;
					if(m_nDNetInfo.m_bMark)
					{
						if(m_nNewIndex[i]==pBranch->m_nHeadNode)
						{
							wFirstNodeVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
							dV=(pBranch->m_wPHead*pBranch->m_wR+pBranch->m_wQHead*pBranch->m_wX)*(1e-3)/m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
							m_nNodeArray[pBranch->m_nTailNode].wVoltage=m_nNodeArray[pBranch->m_nHeadNode].wVoltage-dV;
							if(pBranch->m_nType==TRANS)
								m_nNodeArray[pBranch->m_nTailNode].wVoltage/=pBranch->m_wRatio;
							if(dVB_N<fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage))
								dVB_N=fabs(m_nNodeArray[pBranch->m_nTailNode].wVoltage-wFirstNodeVoltage);
						}
						if(m_nNewIndex[i]==pBranch->m_nTailNode)
						{
							wFirstNodeVoltage=m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
							dV=(pBranch->m_wPTail*pBranch->m_wR+pBranch->m_wQTail*pBranch->m_wX)*(1e-3)/m_nNodeArray[pBranch->m_nTailNode].wVoltage;
							m_nNodeArray[pBranch->m_nHeadNode].wVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage-dV;
							if(dVB_N<=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage))
								dVB_N=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage);
						}
					}
					else
						//标吆值
					{
						if(m_nNewIndex[i]==pBranch->m_nHeadNode)
						{
							wFirstNodeVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage;
							dV=(pBranch->m_wPTail*pBranch->m_wRB+pBranch->m_wQTail*pBranch->m_wXB)/m_nNodeArray[pBranch->m_nTailNode].wVoltage;
							m_nNodeArray[pBranch->m_nHeadNode].wVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage-dV;
							if(dVB_N<=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage))
								dVB_N=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage);
						}
						if(m_nNewIndex[i]==pBranch->m_nTailNode)
						{
							wFirstNodeVoltage=m_nNodeArray[pBranch->m_nHeadNode].wVoltage;
							dV=(pBranch->m_wPTail*pBranch->m_wRB+pBranch->m_wQTail*pBranch->m_wXB)/m_nNodeArray[pBranch->m_nTailNode].wVoltage;
							m_nNodeArray[pBranch->m_nHeadNode].wVoltage=m_nNodeArray[pBranch->m_nTailNode].wVoltage-dV;
							if(dVB_N<=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage))
								dVB_N=fabs(m_nNodeArray[pBranch->m_nHeadNode].wVoltage-wFirstNodeVoltage);
						}
					}
				}
			}
		}
	}
	return dVB_N;
}
/////////////////////////////
//DNet load flow
//////////////////////////////
void CDNet::DNetFlow()
{
	for(INT i=1;i<=m_nDNetInfo.nFeederRoot;++i)
	{
		INT nInter=0;
		INT nInter1=0;
		INT bMark=2;
		double dV=m_nDNetInfo.wVB;
		CFeeder* pFeeder;
		m_nFeederMap.Lookup(i,pFeeder);
		while(bMark&&nInter1<3)
		{
			while(dV>m_nDNetInfo.wVoltageConvergence&&
				nInter<m_nDNetInfo.nMaxIteration)
			{
				ModifyPower0(i);
				GetPower(i);
				dV=GetVoltage(i);
				++nInter;
			}
			for(INT k=1;k<=m_nDNetInfo.nNode;++k)
				TRACE("%d	%f	%f	%f\n",k,m_nNodeArray[k].wVoltage,m_nNodeArray[k].wP,m_nNodeArray[k].wQ);
			bMark=ModifyPower(i);
			if(bMark)
			{
				EnergyToPower();
				dV=m_nDNetInfo.wVB;
				nInter=0;
			}
			++nInter1;
		}
	}
}	//end

INT CDNet::ModifyPower(INT nIndex)
{
	double valueAP,valueAQ;
	CFeeder* pFeeder;
	m_nFeederMap.Lookup(nIndex,pFeeder);
	INT system=m_nNodeSubSystem[pFeeder->nNode];
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch=new CBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		if(pBranch->m_nHeadNode==pFeeder->nNode)
		{
			pFeeder->wComputerAP=1e3*pBranch->m_wPHead*m_nDNetInfo.wRuntime;
			valueAP=fabs(pFeeder->wMeasureAP-pFeeder->wComputerAP);
			pFeeder->wComputerAQ=1e3*pBranch->m_wQHead*m_nDNetInfo.wRuntime;
			valueAQ=fabs(pFeeder->wMeasureAQ-pFeeder->wComputerAQ);
			break;
		}
		if(pBranch->m_nTailNode==pFeeder->nNode)
		{
			pFeeder->wComputerAP=1e3*pBranch->m_wPTail*m_nDNetInfo.wRuntime;
			valueAP=fabs(pFeeder->wMeasureAP-pFeeder->wComputerAP);
			pFeeder->wComputerAQ=1e3*pBranch->m_wQTail*m_nDNetInfo.wRuntime;
			valueAQ=fabs(pFeeder->wMeasureAQ-pFeeder->wComputerAQ);
			break;
		}
	}
	BOOL markP=TRUE;
	BOOL markQ=TRUE;
	if(fabs(valueAP)>pFeeder->wMeasureAP*m_nDNetInfo.wErrorA)
	{
		markP=FALSE;
		double SnTotal=GetTotalSn(nIndex);
		for(pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
		{
			UINT key=0;
			CBeginInfo* pBegin;
			m_nBeginInfoMap.GetNextAssoc(pos,key,pBegin);
			if(m_nNodeSubSystem[pBegin->m_nLoadNode]==system&&
				m_nTranKey[key])
			{
				CBranch* pBranch;
				m_nBranchMap.Lookup(m_nTranKey[key],pBranch);
				pBegin->m_AP+=valueAP*pBranch->m_SnTRANS/SnTotal;
			}
		}
	}
	if(fabs(valueAQ)>pFeeder->wMeasureAQ*m_nDNetInfo.wErrorA)
	{
		markQ=FALSE;
		double SnTotal=GetTotalSn(nIndex);
		for(pos=m_nBeginInfoMap.GetStartPosition();pos!=NULL;)
		{
			UINT key=0;
			CBeginInfo* pBegin;
			m_nBeginInfoMap.GetNextAssoc(pos,key,pBegin);
			if(m_nNodeSubSystem[pBegin->m_nLoadNode]==system&&
				m_nTranKey[key])
			{
				CBranch* pBranch;
				m_nBranchMap.Lookup(m_nTranKey[key],pBranch);
				pBegin->m_AQ+=valueAQ*pBranch->m_SnTRANS/SnTotal;
			}
		}
	}
	if(!markP&&markQ)	return 1;
	if(markP&&!markQ)	return 2;
	if(!markP&&!markQ)	return 3;
	return 0;
}

double CDNet::GetTotalSn(INT nIndex)
{
	double SnTotal=0;
	CFeeder* pFeeder;
	m_nFeederMap.Lookup(nIndex,pFeeder);
	INT system=m_nNodeSubSystem[pFeeder->nNode];
	for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
	{
		UINT key=0;
		CBranch* pBranch;
		m_nBranchMap.GetNextAssoc(pos,key,pBranch);
		if(pBranch->m_nType==TRANS&&m_nBranchSubSystem[key]==system)
			SnTotal+=pBranch->m_SnTRANS;
	}
	return SnTotal;

}
/////////////////////////////////////
//CDNet Result
///////////////////////////////////////

BOOL CDNet::GetNodeVsEle(UINT nElement,UINT& nNode)
{
	if(nElement>m_nDNetInfo.nMaxElement||nElement<=0)
		return FALSE;
	nNode=m_nMaxElementArray[nElement];
	return TRUE;
}


BOOL CDNet::BranchWasteA(INT nIndex,UINT& head,UINT& tail,double& PWaste,
						double& QWaste)
{
	if(nIndex > m_nDNetInfo.nTBranch||nIndex<=0||m_nBranchMap[nIndex]->m_nType==TRANS)
		return FALSE;
	if(m_nBranchMap[nIndex]->m_bState==FALSE)
		return FALSE;
	head=m_nBranchMap[nIndex]->m_nHeadElement;
	tail=m_nBranchMap[nIndex]->m_nTailElement;
	PWaste=fabs(m_nBranchMap[nIndex]->m_wPHead-m_nBranchMap[nIndex]->m_wPTail);
	QWaste=fabs(m_nBranchMap[nIndex]->m_wQHead-m_nBranchMap[nIndex]->m_wQTail);
	if(!m_nDNetInfo.m_bMark)
	{
		PWaste=PWaste*m_nDNetInfo.wSB;
		QWaste=QWaste*m_nDNetInfo.wSB;
	}
	PWaste*=m_nDNetInfo.wRuntime*1000;
	QWaste*=m_nDNetInfo.wRuntime*1000;
	return TRUE;
}

BOOL CDNet::TransWasteA(INT nIndex,UINT& head,UINT& tail,double& PFeWaste,
					   double& QFeWaste,double& PCuWaste,double& QCuWaste)
{
	if(nIndex>m_nDNetInfo.nTBranch||nIndex<=0||m_nBranchMap[nIndex]->m_nType==BRANCH)
		return FALSE;
	if(m_nBranchMap[nIndex]->m_bState==FALSE)
		return FALSE;
	for(INT i=1;i<=m_nDNetInfo.nFeederRoot;++i)
	{
		CFeeder* pFeeder;
		m_nFeederMap.Lookup(i,pFeeder);
		INT system=m_nNodeSubSystem[pFeeder->nNode];
		if(m_nBranchSubSystem[nIndex]==system)
		{
			head=m_nBranchMap[nIndex]->m_nHeadElement;
			tail=m_nBranchMap[nIndex]->m_nTailElement;
			PFeWaste=fabs((1e-3)*m_nBranchMap[nIndex]->m_dP0TRANS*m_nNodeArray[m_nBranchMap[nIndex]->m_nHeadNode].wVoltage*
					m_nNodeArray[m_nBranchMap[nIndex]->m_nHeadNode].wVoltage/(m_nBranchMap[nIndex]->m_VnTRANS*
					m_nBranchMap[nIndex]->m_VnTRANS));
			QFeWaste=fabs((1e-3)*0.01*m_nBranchMap[nIndex]->m_CurrentTRANS*m_nBranchMap[nIndex]->m_SnTRANS*
					m_nNodeArray[m_nBranchMap[nIndex]->m_nHeadNode].wVoltage*
					m_nNodeArray[m_nBranchMap[nIndex]->m_nHeadNode].wVoltage/(m_nBranchMap[nIndex]->m_VnTRANS*
					m_nBranchMap[nIndex]->m_VnTRANS));
			PCuWaste=fabs(m_nBranchMap[nIndex]->m_wPHead-m_nBranchMap[nIndex]->m_wPTail-PFeWaste);
			QCuWaste=fabs(m_nBranchMap[nIndex]->m_wQHead-m_nBranchMap[nIndex]->m_wQTail-QFeWaste);
			if(!m_nDNetInfo.m_bMark)
			{
				PFeWaste*=m_nDNetInfo.wSB;
				QFeWaste*=m_nDNetInfo.wSB;
				PCuWaste*=m_nDNetInfo.wSB;
				QCuWaste*=m_nDNetInfo.wSB;
			}
			PFeWaste*=m_nDNetInfo.wRuntime*1000;
			QFeWaste*=m_nDNetInfo.wRuntime*1000;
			PCuWaste*=m_nDNetInfo.wRuntime*1000;
			QCuWaste*=m_nDNetInfo.wRuntime*1000;
			return TRUE;
		}
	}
	return FALSE;
}


int CDNet::GetMaxEle()
{
	return m_nDNetInfo.nMaxElement;
}

int CDNet::GetnBranch()
{
	return m_nDNetInfo.nTBranch;
}


void CDNet::GetTotalWaste(double& WasteAP,double& WasteAQ)
{
	WasteAP=0;
	WasteAQ=0;
	for(INT i=1;i<=m_nDNetInfo.nFeederRoot;++i)
	{
		CFeeder* pFeeder;
		m_nFeederMap.Lookup(i,pFeeder);
		INT system=m_nNodeSubSystem[pFeeder->nNode];
		for(POSITION pos=m_nBranchMap.GetStartPosition();pos!=NULL;)
		{
			UINT key=0;
			CBranch* pBranch;
			m_nBranchMap.GetNextAssoc(pos,key,pBranch);
			if(!pBranch->m_bState)	continue;
			if(m_nBranchSubSystem[key]==system)
			{
				WasteAP+=fabs(pBranch->m_wPHead-pBranch->m_wPTail);
				WasteAQ+=fabs(pBranch->m_wQHead-pBranch->m_wQTail);
			}
		}
	}
	WasteAP*=m_nDNetInfo.wRuntime*1000;
	WasteAQ*=m_nDNetInfo.wRuntime*1000;
}
BOOL CDNet::GetFeeder(INT nIndex,double& MeaAP,double& MeaAQ,
					  double& AP,double& AQ)
{
	if(nIndex<0||nIndex>m_nDNetInfo.nFeederRoot)
		return FALSE;
	MeaAP=m_nFeederMap[nIndex]->wMeasureAP;
	MeaAQ=m_nFeederMap[nIndex]->wMeasureAQ;
	AP=m_nFeederMap[nIndex]->wComputerAP;
	AQ=m_nFeederMap[nIndex]->wComputerAQ;
	return TRUE;
}

INT CDNet::GetFeederNumber()
{
	return m_nDNetInfo.nFeederRoot;
}


void CDNet::GetOverLoadRatio(double* pData)
{
	for(int i=1;i<=m_nDNetInfo.nFeederRoot;++i)
	{
		double Sn=GetTotalSn(i);
		CFeeder* pFeeder;
		m_nFeederMap.Lookup(i,pFeeder);
		double MeaSn=sqrt(pFeeder->wMeasureAP*pFeeder->wMeasureAP+
			pFeeder->wMeasureAQ*pFeeder->wMeasureAQ);
		if(Sn!=0)
			pData[i]=MeaSn/Sn;
		else
			pData[i]=-1;
	}
}