cnetflow.cpp

电力系统潮流程序adsfasdfasfd

	m_u_vec.resize(m_branch_num);//???
	m_d_vec.resize(m_node_num);
	m_nusum_vec.resize(m_node_num);
	for(i = 0;i < m_node_num-1;++i)
	{
		//如果是计算B",并且是pv节点
		if(2 == flag && i == i_pv)
		{
			n_pv ++;
			i_pv = m_allflow_dev_vec.pvnode_vec[count].i;
			m_nusum_vec[i] = 0;
			m_d_vec[i] = 0;
			
		}
		else
		{
			for(count = i+1;count < m_node_num-1;++count)
			{
				B[count]= 0.0;	 
			}
			B[i] = m_yii1_vec[i].b;
			for(count  = m_nyseq_vec[i];count <m_nyseq_vec[i+1];++count)
			{
				j = m_yij1_vec[count].j;
				B[j] = m_yij1_vec[count].b;
			}
			if(2 == flag)
			{
				for(count  = 0;count < m_allflow_dev_vec.pvnode_vec.size();++count)
				{
					j = m_allflow_dev_vec.pvnode_vec[count].i;
					B[j] = 0;
				}
			}
			n_u = 0;
			i_above = 0;
			while(i_above <= i-1)
			{
				count = 1;
				while(count <= m_nusum_vec[i_above])
				{
					if(m_u_vec[n_u].j == i)//?
					{
						Btemp = m_u_vec[n_u].value/m_d_vec[i_above];
						while(count <= m_nusum_vec[i_above])
						{
							j = m_u_vec[n_u].j;
							B[j] -= Btemp*m_u_vec[n_u].value;
							count++ ;
							n_u++;
						}
						break;
					}
					else
					{
						count++;
						n_u++;
					}
				}
				
				i_above++;
			}
			Btemp = 1/B[i];
			m_d_vec[i] = Btemp;
			count = 0;
			for(j= i+1;j<m_node_num-1;j++)
			{
				if(B[j] != 0)
				{
					float  value= B[j];
					m_u_vec[n_u].value = B[j]*Btemp;
					m_u_vec[n_u].j = j;
					count++;
					n_u++;
				}
			}
			m_nusum_vec[i] = count;
		}
	}
	for(i = 0; i<m_node_num;++i)
	{
		printf("i === %d,d === %f\n",i,m_d_vec[i]);
	}
	for(i = 0; i<m_node_num;++i)
	{
		printf("i === %d,u === %f\n",i,m_u_vec[i].value);
	}
}
//回代求解方程的解
//m_DI为解向量
void CNetFlow::BackSubstitution()
{
	int n_u = 0;
	int i,count,j;
	double DItemp;
        //对b向量进行前代
	for(i = 0;i < m_node_num-1;i++)
	{
		DItemp = m_DI[i];
		for(count = 0;count < m_nusum_vec[i];count++)
		{
			j = m_u_vec[n_u].j;
			float temp1 = m_u_vec[n_u].value;
			//m_DI[j] = m_DI[i] - DItemp*m_u_vec[n_u].value;书本上是m_DI[i]
			m_DI[j] = m_DI[j] - DItemp*m_u_vec[n_u].value;
			n_u++;
		}
		float temp1 = m_d_vec[i];
		m_DI[i] = DItemp*m_d_vec[i];
	}
	//回代求解
	for(i = m_node_num-2;i>=0 ;i--)
	{
		DItemp = m_DI[i];
		for(count = 0;count < m_nusum_vec[i];count++)//?
		{
			n_u--;
			j = m_u_vec[n_u].j;
			DItemp -= m_DI[j]*m_u_vec[n_u].value;
		}
		m_DI[i] = DItemp;
	}

	for(i = 0; i<m_node_num;++i)
	{
		printf("i === %d,theta === %f\n",i,m_DI[i]);
	}
}
//迭代计算节点功率
void CNetFlow::CalNodePower(int flag)
{
    int          i,n;
    float        vi;
    float        A,B,VV;
	int k;
	int j;
	int theta;
    m_node_p.resize(m_node_num,0.0);
    m_node_q.resize(m_node_num,0.0);

    for(i = 0;i < m_node_num;i++)
    {
        vi = m_ndvolt_vec[i].v;
        //计算p
        if(flag == 1)
        {
            A = m_yii_vec[i].g;
            m_node_p[i] += vi*vi*A;
        }
        else
        {
            A = -m_yii_vec[i].b;
            m_node_q[i] += vi*vi*A;
        }
        for(n = m_nyseq_vec[i];n < m_nyseq_vec[i+1];++n)
        {
            if(flag == 1)
            {
                A = m_yij_vec[n].g;
                B = m_yij_vec[n].b;
                j = m_yij_vec[n].j;
                VV = vi*m_ndvolt_vec[j].v;
                theta = m_ndvolt_vec[i].theta - m_ndvolt_vec[j].theta;
                A = A*VV*cos(theta);
                B = B*VV*sin(theta);
                m_node_p[i] = m_node_p[i]+A+B;
				
                m_node_p[j] = m_node_p[j]+A-B;
				printf("i===%d,m_node_p[i]====%f\n",i,m_node_p[i]);
				printf("i===%d,m_node_p[i]====%f\n",j,m_node_p[j]);
                
            }
            else
            {
                A = -m_yij_vec[n].b;
                B = m_yij_vec[n].g;
                j = m_yij_vec[n].j;
                VV = vi*m_ndvolt_vec[j].v;
                theta = m_ndvolt_vec[i].theta - m_ndvolt_vec[j].theta;
                A = A*VV*cos(theta);
                B = B*VV*sin(theta);
                m_node_q[i] = m_node_q[i]+A+B;
                m_node_q[j] = m_node_q[j]+A-B;
            }
        }
    }
	if(flag == 1)
	{
		for(j = 0; j < m_allflow_dev_vec.load_vec.size();++j)
		{
			i = m_allflow_dev_vec.load_vec[j].i;
			m_DI[i] = (m_allflow_dev_vec.load_vec[j].p - m_node_p[i])/m_ndvolt_vec[i].v;
			printf("111111111i === %d,p === %f\n",i,m_DI[i]);
		}
		for(j = 0; j < m_allflow_dev_vec.gen_vec.size();++j)
		{
			i = m_allflow_dev_vec.gen_vec[j].i;
			m_DI[i] = (m_allflow_dev_vec.gen_vec[j].p - m_node_p[i])/m_ndvolt_vec[i].v;
			printf("111111111i === %d,p === %f\n",i,m_DI[i]);
		}
	}
	else
	{
		for(j = 0; j < m_allflow_dev_vec.load_vec.size();++j)
		{
			i = m_allflow_dev_vec.load_vec[j].i;
			m_DI[i] = (m_allflow_dev_vec.load_vec[j].q - m_node_q[i])/m_ndvolt_vec[i].v;
			printf("2222222222222i === %d,q === %f\n",i,m_DI[i]);
		}
		for(j = 0; j < m_allflow_dev_vec.gen_vec.size();++j)
		{
			i = m_allflow_dev_vec.gen_vec[j].i;
			m_DI[i] = (m_allflow_dev_vec.gen_vec[j].q - m_node_q[i])/m_ndvolt_vec[i].v;
			printf("222222222222i === %d,q === %f\n",i,m_DI[i]);
		}
	}
}
//初始化节点电压
void CNetFlow::InitNodeVolt()
{
    int i,n;
	m_ndvolt_vec.resize(m_node_num);
    for(i = 0;i < m_node_num;i++)
    {
        m_ndvolt_vec[i].v = V0;
        m_ndvolt_vec[i].theta = THETA0;
    }
    for(n = 0;n < m_allflow_dev_vec.pvnode_vec.size();++n)
    {
        i = m_allflow_dev_vec.pvnode_vec[n].i;
        m_ndvolt_vec[i].v = m_allflow_dev_vec.pvnode_vec[n].v;
    }

	m_ndvolt_vec[0].v = V0;
	m_ndvolt_vec[0].theta = THETA0;
	m_ndvolt_vec[1].v = V0;
	m_ndvolt_vec[1].theta = THETA0;
	m_ndvolt_vec[2].v = V0;
	m_ndvolt_vec[2].theta = THETA0;
	m_ndvolt_vec[3].v = 1.05;
	m_ndvolt_vec[3].theta = THETA0;
	m_ndvolt_vec[4].v = 1.05;
	m_ndvolt_vec[4].theta = THETA0;
}

//计算潮流偏差，是否已经收敛
void CNetFlow::CalError(int flag)
{
    float maxError = 0.0;
    int errorNode;
    int i(0),n_g(0),n_1(0),n_pv(0);
    int i_g = m_allflow_dev_vec.gen_vec[0].i;
    int i_l = m_allflow_dev_vec.load_vec[0].i;
    int i_pv = m_allflow_dev_vec.pvnode_vec[0].i;
    
    float vi = m_ndvolt_vec[i].v;
    float wi,wtemp;
	while(1)
    {
		if(i == i_l)
		{
			if(flag == 1)
			{
				wi = m_allflow_dev_vec.load_vec[n_1].p;
			}
			else
			{
				wi = m_allflow_dev_vec.load_vec[n_1].q;
			}
			n_1++;
			i_l == m_allflow_dev_vec.load_vec[n_1].i;
		}
		else
		{
			wi = 0;
		}
		wtemp = wi;
		//有功
		if(flag == 1)
		{
			wi -= m_node_p[i];
		}
		else
		{
			wi -= m_node_q[i];
		}
		if(i == i_g)
		{
			if(flag == 1)
			{
				m_node_p[i] = wtemp;
				m_allflow_dev_vec.gen_vec[i_g].p = -wi;
				wi += m_allflow_dev_vec.gen_vec[n_g].p;
			}
			else
			{
				m_node_q[i] = wtemp;
				m_allflow_dev_vec.gen_vec[i_g].q = -wi;
				wi += m_allflow_dev_vec.gen_vec[n_g].q;
			}
			n_g++;
			i_g = m_allflow_dev_vec.gen_vec[n_g].i;
		}	
		if(i != m_node_num)
		{
			if( flag == 2  && i == i_pv)
			{
				n_pv++;
				i_pv = m_allflow_dev_vec.pvnode_vec[n_pv].i;
				m_DI[i] = 0;
			}
			else
			{
				if(abs(wi)> maxError)
				{
					maxError = abs(wi);
					errorNode = i;
				}
				m_DI[i] = wi/vi;
			}
			i++; 
		}
		else
			return;
	}
}
//根据迭代结果对电压进行修正
void CNetFlow::AmendVolt(int flag)
{
	float dtheta;
	float dv;
    int i;
	set<int> pv_set;
	for(i = 0;i < m_allflow_dev_vec.pvnode_vec.size();++i)
	{
		pv_set.insert(m_allflow_dev_vec.pvnode_vec[i].i);
	}

	for(i = 0;i<m_node_num;++i)
	{
		if(pv_set.find(i) != pv_set.end())
			continue;
		if(flag == 1)
		{
			dtheta = m_DI[i]/V0;
			m_ndvolt_vec[i].theta = m_ndvolt_vec[i].theta-dtheta;
		}
		else
		{
			dv = m_DI[i];
			m_ndvolt_vec[i].v = m_ndvolt_vec[i].v - dv;
			
		}
	}

	for(i = 0;i<m_node_num;++i)
	{
		if(flag == 1)
		{
			printf("i === %d,theta====%f\n",i,m_ndvolt_vec[i].theta);
		}
		else
		{	
			printf("i === %d,v====%f\n",i,m_ndvolt_vec[i].v);
		}
		
	}
}
//计算支路潮流
void CNetFlow::CalBranchFlow()
{
    float ploss = 0.0;
    float qloss = 0.0;
    int   n;
    int   i,j;
    float r,x,yk;
    float vi,theta,ei,fi;
    float vj,ej,fj;
    float de,df;
    float zmag2;
    float ir,ii;
    float pij,qij;
    float pji,qji;
    for(n = 0;n < m_allflow_dev_vec.branch_vec.size();++n)
    {
        i = abs(m_allflow_dev_vec.branch_vec[n].i);
        j = abs(m_allflow_dev_vec.branch_vec[n].j);
        r = m_allflow_dev_vec.branch_vec[n].r;
        x = m_allflow_dev_vec.branch_vec[n].x;
        yk = m_allflow_dev_vec.branch_vec[n].yk;
        
        vi = m_ndvolt_vec[i].v;
        theta = m_ndvolt_vec[i].theta;
        ei = vi*cos(theta);
        fi = vi*sin(theta);
        
        vj = m_ndvolt_vec[j].v;
        theta = m_ndvolt_vec[j].theta;
        ej = vj*cos(theta);
        fj = vj*sin(theta);
        //如果是变压器支路
        if(m_allflow_dev_vec.branch_vec[n].i<0 || m_allflow_dev_vec.branch_vec[n].j<0)
        {
            if(m_allflow_dev_vec.branch_vec[n].i<0)
            {
                ei = ei/yk;
                fi = fi/yk;
            }
            else
            {
                ej = ej/yk;
                fj = fj/yk;
            }
            yk = 0.0;
        }
        de = ei-ej;
        df = fi-fj;
        zmag2 = r*r+x*x;
        ir = (de*r+df*x)/zmag2;
        ii = (de*r-df*x)/zmag2;
        pij = ir*ei+ii*fi;
        qij = ir*fi - ii*ei;
        pji = -ir*ej-ii*fj;
        qji = -ir*fj+ii*ej;
        
        qij = qij - vi*vi*yk/2.0;
        qji = qji - vj*vj*yk/2.0;
        
        ploss = ploss + pij + pji;
        qloss = qloss + qij + qji;
        
    }
}