📄 dnet.cpp

📁 这是一个简单电网结构分析计算的源代码
💻 CPP
📖 第 1 页 / 共 3 页
字号:
12 3 下一页
#include"stdafx.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.nLoad=0;
	m_nDNetInfo.wErrorA=0.01;
	m_nDNetInfo.wDNetPWaste=0;

}


void CDNet::Initialize()
{
	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,
						  double measureAP,double measureAQ,
						  double convergenceP,double convergenceQ)
{
	CFeeder* pFeeder;
	if(!m_nFeederMap.Lookup(nIndex,pFeeder))
	{
		pFeeder=new CFeeder;
		m_nFeederMap[nIndex]=pFeeder;
		++m_nDNetInfo.nFeederRoot;
	}
	pFeeder->nOrder=nIndex;
	pFeeder->wVoltage=voltage;
	pFeeder->nElement=nElement;
	pFeeder->nNode=nElement;
	pFeeder->wMeasureAP=measureAP;
	pFeeder->wMeasureAQ=measureAQ;
	pFeeder->wConvergenceP=convergenceP*measureAP;
	pFeeder->wConvergenceQ=convergenceQ*measureAQ;

	if(m_nDNetInfo.nMaxElement<nElement)
		m_nDNetInfo.nMaxElement=nElement;
}
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::AddBranch(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;
	}
	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::AddTrans(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;
	}
	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::AddCable(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);
	}
	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 AP,double AQ,
						 double a,BOOL nType)
{
	CBeginInfo* pBeginInfo;
	if(!m_nBeginInfoMap.Lookup(nIndex,pBeginInfo))
	{
		if(!nType&&(AP<0||AQ<0))
		{
			CString str="原始数据有误，请自动终止程序";
			CString str1="警告";
			MessageBox(NULL,str,str1,MB_ICONWARNING);
			return;
		}
		pBeginInfo=new CBeginInfo;
		m_nBeginInfoMap[nIndex]=pBeginInfo;
		pBeginInfo->nOrder=nIndex;
		pBeginInfo->bType=nType;
		pBeginInfo->m_AP=AP;
		pBeginInfo->m_AQ=AQ;
		pBeginInfo->m_wA=a;
		pBeginInfo->m_PK=sqrt(0.5+(1+a)*(1+a)/(8*a));
		pBeginInfo->m_QL=sqrt(0.5+(1+a)*(1+a)/(8*a));
		pBeginInfo->m_nLoadIndex=nNode;
		pBeginInfo->m_nLoadNode=nNode;
		++m_nDNetInfo.nLoad;
	}
	if(m_nDNetInfo.nMaxElement<pBeginInfo->m_nLoadIndex)
		m_nDNetInfo.nMaxElement=pBeginInfo->m_nLoadIndex;
}



void CDNet::AddSwitch(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;
	}
	if(m_nDNetInfo.nMaxElement<pSwitch->nHeadElement)
		m_nDNetInfo.nMaxElement=pSwitch->nHeadElement;
	if(m_nDNetInfo.nMaxElement<pSwitch->nTailElement)
		m_nDNetInfo.nMaxElement=pSwitch->nTailElement;
}

void CDNet::SetSwitchState0(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::AddCap(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::SetBasicInfo(double SBvalue,double VBvalue)
{
	m_nDNetInfo.wSB=SBvalue;
	m_nDNetInfo.wVB=VBvalue;
}

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

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

void CDNet::SetMark0(BOOL mark)
{
	m_nDNetInfo.m_bMark=mark;
}
void CDNet::SetErrorA(double value)
{
	value=m_nDNetInfo.wErrorA;
}

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

void CDNet::SetRuntime(double time)
{
	m_nDNetInfo.wRuntime=time;
}
///////////////////////////////////////////
///operation
////////////////////////////////////////////
void CDNet::CreateNodeEle()
{
	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;
12 3 下一页
💿 文件大小 43 K
👤 上传用户 zhongcheng211
📂 所属分类嵌入式/单片机编程
🏷️ 相关标签

#电网 #源代码 #结构分析 #计算
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -