#include "pch.h"
#include "ACSysMG.h"
#include <math.h>
#include <chrono>
#include <ctime>
#include <sstream>
#include <iomanip>


void ACSysMG::SetPQValueArr(DCNodePQValue PQValueArr[])		//设置PQ矩阵数组
{
	p_PQValueArr=PQValueArr;
}
ACSysMG::ACSysMG(void)
{
	p_PQValueArr=nullptr;
	m_nMaxSigleArrowTrainNums = Max_SigleArrowTrain_Nums;
	m_nAllPowerStationNums = All_Power_Station_Nums;

	ACNodeMatrix=new RX *[m_nMaxSigleArrowTrainNums];
	for (int i=0;i< m_nMaxSigleArrowTrainNums;i++)
	{
		ACNodeMatrix[i]=new RX[m_nMaxSigleArrowTrainNums];
	}
	E=new double[m_nMaxSigleArrowTrainNums];
	F=new double[m_nMaxSigleArrowTrainNums];
	P=new double[m_nMaxSigleArrowTrainNums];
	Q=new double[m_nMaxSigleArrowTrainNums];

	m_pElectricEqpmtMap=nullptr;
}

void ACSysMG::UpdataTrainData(DCSysTrain* pTrain)
{
}

ACSysMG::~ACSysMG(void)
{	
	m_CritilSecEqpmt.lock();
	if (ACNodeMatrix!=nullptr)
	{
		for (int i=0;i< m_nMaxSigleArrowTrainNums;i++)
		{
			if(ACNodeMatrix[i]==nullptr)
			{
				continue;
			}
			delete[] ACNodeMatrix[i];
			ACNodeMatrix[i]=nullptr;
		}
		delete[] ACNodeMatrix;
		ACNodeMatrix=nullptr;
	}	
	delete[] E;
	E=nullptr;
	delete[] F;
	F=nullptr;
	delete[] P;
	P=nullptr;
	delete[] Q;
	Q=nullptr;
// 	for (EqpmtMap::iterator iterd=m_EqpmtInfoMap.begin();iterd!=m_EqpmtInfoMap.end();iterd++)
// 	{
// 		if (iterd->second!=nullptr)
// 		{
// 			delete iterd->second;
// 			iterd->second=nullptr;
// 		}		
// 	}
// 	m_EqpmtInfoMap.clear();
	m_CritilSecEqpmt.unlock();
	
}

bool ACSysMG::AddPQNodeData(CalNode& node)					//增加PQ节点数据
{
	if (node.ID>=0)
	{
		m_PQNodes.push_back(node);
		return true;
	}
	return false;
}

bool ACSysMG::AddEqpmtData(EqpmtInfo* pEqpmt)					//增加设备数据（ID，状态，种类，ID名字）
{
	if (pEqpmt!=nullptr)
	{
		m_CritilSecEqpmt.lock();
		m_EqpmtInfoMap.insert(make_pair(pEqpmt->GetID(),pEqpmt));//向设备信息表中增加设备的信息
		m_CritilSecEqpmt.unlock();
		return true;
	}
	return false;
}



double ACSysMG::CalQiValue(int i)				//计算第i个节点的无功功率值，
{
	double sume=0;
	double sumf=0;
	if (i< m_nMaxSigleArrowTrainNums &&i<m_PQNodes.size())
	{
		for (int k=0;k<m_PQNodes.size();k++)
		{
			//ACNodeMatrix 交流侧节点矩阵
			sume+=(ACNodeMatrix[i][k].R*E[k]-ACNodeMatrix[i][k].X*F[k]);////Qi值的实部计算，P25，公式（3-41）
			sumf+=(ACNodeMatrix[i][k].R*F[k]+ACNodeMatrix[i][k].X*E[k]);//Qi值的虚部计算，P25，公式（3-41）
		}	
	}
	return F[i]*sume-E[i]*sumf;
}

bool ACSysMG::CalYKBMatriX()			//计算雅可比矩阵在进行求解时误差判断，是否小于迭代精度，如不满足给出的迭代精度，则需一直迭代计算////
{
	m_EquationCalcul.jisuan();
	if (!m_EquationCalcul.CheckResult())
	{
		return false;
	}
	bool Stop=true;
	int ntest=m_PQNodes.size()-1;
	for(int n=0; n <ntest ; n++)
	{
		if (n>111)
		{
			int xyx=1;
		}

		int row = 2*n;
		int colom = m_EquationCalcul.lie-1;
		double bvalue = m_EquationCalcul.b[2*n][m_EquationCalcul.lie-1];
		double err = EF_Calculate_Offsize;
		if ((m_EquationCalcul.b[2*n][m_EquationCalcul.lie-1]>EF_Calculate_Offsize)||(m_EquationCalcul.b[2*n][m_EquationCalcul.lie-1]<-EF_Calculate_Offsize))	//偶数行
		{//用于计算F[n]			//#define   EF_Calculate_Offsize     0.001//?计算时间偏移差
			Stop=false;
		}
		int row2 = 2*n+1;
		int colom2 = m_EquationCalcul.lie-1;
		double bvalue2 = m_EquationCalcul.b[2*n+1][m_EquationCalcul.lie-1];
		if ((m_EquationCalcul.b[2*n+1][m_EquationCalcul.lie-1]>EF_Calculate_Offsize)||(m_EquationCalcul.b[2*n+1][m_EquationCalcul.lie-1]<-EF_Calculate_Offsize))	//奇数行
		{//用于计算E[n]
			Stop=false;
		}
		double c=F[n+1]-m_EquationCalcul.b[2*n][m_EquationCalcul.lie-1];
		double d=E[n+1]-m_EquationCalcul.b[2*n+1][m_EquationCalcul.lie-1];
		F[n+1]=F[n+1]-m_EquationCalcul.b[2*n][m_EquationCalcul.lie-1];					//系统功率偏差向量的迭代，P27，公式（3-37）
		E[n+1]=E[n+1]-m_EquationCalcul.b[2*n+1][m_EquationCalcul.lie-1];
	}

	//TRACE("E0%f,f0%f\n",E[0],F[0]);
	//TRACE("E1%f,f1%f\n",E[1],F[1]);
	return Stop;
}

void ACSysMG::CalResult( )					//计算节点的电压，功率，电流；计算消耗功率的有功功率的输入输出电流，无功功率的输入输出电流
{
	m_CritilSecEqpmt.lock();
	for(int n=1;n<m_PQNodes.size();n++)
	{
		F[n] =m_PQNodes[n].F;
		E[n] = m_PQNodes[n].E;
		double a = sqrt(F[n]*F[n]+E[n]*E[n]);							//E[n]，F[n]，第n个节点的电压的实部与虚部
		
		//测试
		if ( n>106)
		{
			double x=E[n];
			double y=a*35000;
			int yur=1;
		}

		double e=E[n];
		double b=a*35000;
		m_PQNodes[n].OutputV=a;											//节点电压的计算
		
		//与节点关联的馈线m_SubLines电流值的计算
		for (int e=0;e<m_PQNodes[n].m_SubLines.size();e++)              //节点所关联的馈线相关电气量计算 xyx注释
		{
			double p =m_PQNodes[n].m_SubLines[e].P/Sac;					//第n个节点的功率的实部。。（公式（3-31））。。。。Sac为交流侧容量基准值（通过此公式计算有功功率的标幺值）
			double q = m_PQNodes[n].m_SubLines[e].Q/Sac;				//第n个节点的功率的虚部（公式（3-31）
			double s= sqrt(p*p+q*q);									//第n个节点功率的计算，此处的n为任意数
			m_PQNodes[n].m_SubLines[e].I=(s/m_PQNodes[n].OutputV)*Iac;  //第n个节点的电流计算(P=UI)
		}
		//xyx新增 begin 
		//(1)将母线节点电压计算结果赋给相应的母线图元设备
		if (m_pElectricEqpmtMap!=nullptr)
		{
			ELEEQPMTMAP::iterator iterBusEqpmt=m_pElectricEqpmtMap->find(m_PQNodes[n].BgkID);
			if (iterBusEqpmt!=m_pElectricEqpmtMap->end())
			{
				if (iterBusEqpmt->second->GetPower())
				{
					iterBusEqpmt->second->m_EqpmtPowerValue.U = m_PQNodes[n].OutputV* Vac/1000;   //Vac为交流侧电压基准值
					iterBusEqpmt->second->m_EqpmtPowerValue.Uab = m_PQNodes[n].OutputV* Vac/1000;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ubc = m_PQNodes[n].OutputV* Vac/1000;
					iterBusEqpmt->second->m_EqpmtPowerValue.Uca = m_PQNodes[n].OutputV* Vac/1000;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ua = m_PQNodes[n].OutputV* Vac/sqrt(3.0)/1000;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ub = m_PQNodes[n].OutputV* Vac/sqrt(3.0)/1000;
					iterBusEqpmt->second->m_EqpmtPowerValue.Uc = m_PQNodes[n].OutputV* Vac/sqrt(3.0)/1000;

					//若为400V母线节点
					//if(m_PQNodes[n].Category==PowerNode_PQL_Category)
					//{
					//	double P= m_PQNodes[n].ConsumePowerR;
					//	double Q= m_PQNodes[n].ConsumePowerX;
					//	double i= sqrt(P*P+Q*Q)*Sac/(sqrt(3.0)*m_PQNodes[n].OutputV* Vac);   
					//	
					//	iterBusEqpmt->second->m_EqpmtPowerValue.Ia = i/sqrt(3.0);
					//	iterBusEqpmt->second->m_EqpmtPowerValue.Ib = i/sqrt(3.0);
					//	iterBusEqpmt->second->m_EqpmtPowerValue.Ic = i/sqrt(3.0);

					//	iterBusEqpmt->second->m_EqpmtPowerValue.P = P * Sac/1000;
					//	iterBusEqpmt->second->m_EqpmtPowerValue.Q = Q * Sac/1000; 
					//	iterBusEqpmt->second->m_EqpmtPowerValue.PF = P/(sqrt(P*P+Q*Q));
					//}
				}
				else
				{
					iterBusEqpmt->second->m_EqpmtPowerValue.U = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Uab = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ubc = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Uca = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ua = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ub = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Uc = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.I = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ia = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ib = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Ic = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.P = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.Q = 0.0;
					iterBusEqpmt->second->m_EqpmtPowerValue.PF = 0.0;
				}
				iterBusEqpmt->second->m_EqpmtPowerValue.Position = m_PQNodes[n].Position;
			}
			//（2）为与当前节点关联的断路器开关赋值
			for(int k=0;k<m_PQNodes[n].m_RelationsSwitch.size();k++)
			{
				ELEEQPMTMAP::iterator iterSwitchEqpmt=m_pElectricEqpmtMap->find(m_PQNodes[n].m_RelationsSwitch[k]);
				if (iterSwitchEqpmt!=m_pElectricEqpmtMap->end())
				{
					if (iterSwitchEqpmt->second->GetEqpmentType()==Electric_EqpmentType_Breaker)
					{
						if (iterSwitchEqpmt->second->GetPower())
						{
							//开关的电压值
							double Switch_U = m_PQNodes[n].OutputV* Vac;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.U = Switch_U/1000;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uab = Switch_U/1000;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ubc = Switch_U/1000;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uca = Switch_U/1000;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ua = Switch_U/(sqrt(3.0)*1000);
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ub = Switch_U/(sqrt(3.0)*1000);
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uc = Switch_U/(sqrt(3.0)*1000);

							//开关的电流值：通过支路与节点进行计算
							EqpmtMap::iterator iterLine = m_EqpmtInfoMap.begin();
							for (;iterLine!=m_EqpmtInfoMap.end();iterLine++)
							{
								PowerLine* pLine = (PowerLine*)iterLine->second;
								for (int m=0;m<m_PQNodes[n].m_Relations.size();m++)
								{
									if (iterLine->first==m_PQNodes[n].m_Relations[m])
									{
										//（1）若为35kV进出线
										if (iterLine->second->GetCateGory()==Eqpmt_Category_Powerline)
										{
											if(m_PQNodes[n].Category==PowerNode_PQ_Category||m_PQNodes[n].Category==PowerNode_PQD_Category)//若为35kV母线节点关联支路
											{
												if (pLine->GetLlineID()>=0&&pLine->GetLlineID()< m_nMaxSigleArrowTrainNums &&pLine->GetRlineID()>=0&&pLine->GetRlineID()< m_nMaxSigleArrowTrainNums)
												{
													//纯阻抗支路
													double Ir=(pLine->GetR()*(E[pLine->GetLlineID()]-E[pLine->GetRlineID()])+pLine->GetX()*(F[pLine->GetLlineID()]-F[pLine->GetRlineID()]))/(pLine->GetR()*pLine->GetR()+pLine->GetX()*pLine->GetX());
													double Ix=(pLine->GetR()*(F[pLine->GetLlineID()]-F[pLine->GetRlineID()])-pLine->GetX()*(E[pLine->GetLlineID()]-E[pLine->GetRlineID()]))/(pLine->GetR()*pLine->GetR()+pLine->GetX()*pLine->GetX());
													double i_TransLine= sqrt(Ix*Ix+Ir*Ir) * Iac;
											
													iterSwitchEqpmt->second->m_EqpmtPowerValue.I = i_TransLine;
													iterSwitchEqpmt->second->m_EqpmtPowerValue.Ia = i_TransLine/sqrt(3.0);
													iterSwitchEqpmt->second->m_EqpmtPowerValue.Ib = i_TransLine/sqrt(3.0);
													iterSwitchEqpmt->second->m_EqpmtPowerValue.Ic = i_TransLine/sqrt(3.0);
													iterSwitchEqpmt->second->m_EqpmtPowerValue.P = i_TransLine*Switch_U*sqrt(3.0)/1000;
												}
											}
										}
										//（2）若为35kV动力变馈线
										else if (iterLine->second->GetCateGory()==Eqpmt_Category_Powerline_Transformer_35To400)
										{
											//负荷支路电流
											double i_Load= sqrt(m_PQNodes[n].ConsumePowerR*m_PQNodes[n].ConsumePowerR + m_PQNodes[n].ConsumePowerX*m_PQNodes[n].ConsumePowerX)/m_PQNodes[n].OutputV * Iac;
											if (m_PQNodes[n].Category==PowerNode_PQL_Category)  //若为与400V母线关联的开关
											{
												iterSwitchEqpmt->second->m_EqpmtPowerValue.I = i_Load;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ia = i_Load/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ib = i_Load/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ic = i_Load/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.P = m_PQNodes[n].ConsumePowerR * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Q = m_PQNodes[n].ConsumePowerX * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.S = sqrt(m_PQNodes[n].ConsumePowerR*m_PQNodes[n].ConsumePowerR + m_PQNodes[n].ConsumePowerX*m_PQNodes[n].ConsumePowerX) * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.PF = iterSwitchEqpmt->second->m_EqpmtPowerValue.P/iterSwitchEqpmt->second->m_EqpmtPowerValue.S;

											}
											else if(m_PQNodes[n].Category==PowerNode_PQ_Category||m_PQNodes[n].Category==PowerNode_PQD_Category)  //若为与35kV母线关联的开关
											{
												iterSwitchEqpmt->second->m_EqpmtPowerValue.I = i_Load * 0.0114; //动力变压器变比N1：N2=1：K，其中K=0.0114
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ia = i_Load * 0.0114/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ib = i_Load * 0.0114/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Ic = i_Load * 0.0114/sqrt(3.0);
												iterSwitchEqpmt->second->m_EqpmtPowerValue.P = m_PQNodes[n].ConsumePowerR * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.Q = m_PQNodes[n].ConsumePowerX * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.S = sqrt(m_PQNodes[n].ConsumePowerR*m_PQNodes[n].ConsumePowerR + m_PQNodes[n].ConsumePowerX*m_PQNodes[n].ConsumePowerX) * Sac/1000;
												iterSwitchEqpmt->second->m_EqpmtPowerValue.PF = iterSwitchEqpmt->second->m_EqpmtPowerValue.P/iterSwitchEqpmt->second->m_EqpmtPowerValue.S;
											}
										}
										//（3）若为35kV整流变馈线
										else if (iterLine->second->GetCateGory()==Eqpmt_Category_Powerline_Transformer_35ToDC)
										{
											if (m_PQNodes[n].Category==PowerNode_PQD_Category)
											{
												DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.begin();
												for (;iter1!=m_PowerStationNodeMap.end();iter1++)
												{
													Dc_PowerStation&  powerstation = iter1->second;
													for (int k=0;k<All_Power_Station_Nums;k++)
													{
														if (p_PQValueArr[k].StationID==powerstation.GetID())
														{
															//馈线电流=2台整流机组有功功率/（2*母线节点电压）
															double P_QY = p_PQValueArr[k].P_QY/2;
															double Q_QY = p_PQValueArr[k].Q_QY/2;
															double i_QY = P_QY/(m_PQNodes[n].OutputV * Vac);

															iterSwitchEqpmt->second->m_EqpmtPowerValue.I= i_QY;
															iterSwitchEqpmt->second->m_EqpmtPowerValue.Ia = i_QY/sqrt(3.0);
															iterSwitchEqpmt->second->m_EqpmtPowerValue.Ib = i_QY/sqrt(3.0);
															iterSwitchEqpmt->second->m_EqpmtPowerValue.Ic = i_QY/sqrt(3.0);
															iterSwitchEqpmt->second->m_EqpmtPowerValue.P = P_QY;
															iterSwitchEqpmt->second->m_EqpmtPowerValue.Q = Q_QY;
															iterSwitchEqpmt->second->m_EqpmtPowerValue.S = sqrt(P_QY*P_QY+Q_QY*Q_QY);
															iterSwitchEqpmt->second->m_EqpmtPowerValue.PF = P_QY/sqrt(P_QY*P_QY+Q_QY*Q_QY);
														}
													}
												}
											}
										}
										//（4）若为母联支路
										else if (iterLine->second->GetCateGory()==Eqpmt_Category_Powerline_BusTie)
										{
											double U = sqrt(E[pLine->GetLlineID()]*E[pLine->GetLlineID()]+F[pLine->GetLlineID()]*F[pLine->GetLlineID()])*Vac;
											iterSwitchEqpmt->second->m_EqpmtPowerValue.U = U/1000;
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Uab = U/1000;
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Ubc = U/1000;
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Uca = U/1000;
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Ua = U/(sqrt(3.0)*1000);
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Ub = U/(sqrt(3.0)*1000);
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Uc = U/(sqrt(3.0)*1000);
											iterSwitchEqpmt->second->m_EqpmtPowerValue.Uc = U/(sqrt(3.0)*1000);
										}
									}
								}

							}	
						}
						else
						{
							iterSwitchEqpmt->second->m_EqpmtPowerValue.U = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uab = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ubc = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uca = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ua = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ub = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Uc = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.I = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ia = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ib = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Ic = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.P = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.Q = 0.0;
							iterSwitchEqpmt->second->m_EqpmtPowerValue.PF = 0.0;
						}
						iterSwitchEqpmt->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
					}
				}
			}
		}
		//xyx新增 end
	}
	m_CritilSecEqpmt.unlock();
}
bool ACSysMG::CreateYKBMatrix()						//产生雅可比矩阵，雅可比矩阵的产生方法
{
	m_EquationCalcul.Clear();
	m_EquationCalcul.SetHangLie(2*m_PQNodes.size()-2,2*m_PQNodes.size()-1);
	for (int i=1;i<m_PQNodes.size();i++)
	{
		for (int j=1;j<m_PQNodes.size();j++)
		{
			if (i==j)
			{
				double ai=0;				//节点注入电流实部
				double bi =0;				//节点注入电流的虚部
				for (int e=0;e<m_PQNodes.size();e++)
				{
					ai+=ACNodeMatrix[i][e].R*E[e]-ACNodeMatrix[i][e].X*F[e];				//P26，公式（3-46）
					bi+=ACNodeMatrix[i][e].R*F[e]+ACNodeMatrix[i][e].X*E[e];
				}
				//根据节点电流产生对应的雅可比矩阵
				double Hii= ACNodeMatrix[i][i].X*E[i]-bi-ACNodeMatrix[i][i].R*F[i];			//H矩阵，P26，公式（3-45）//E[i],F[i]分别为节点电压实部和虚部
				m_EquationCalcul.SetParam((i-1)*2,(i-1)*2,Hii);								//给对应矩阵a元素赋值
				double Nii= -ai-ACNodeMatrix[i][i].R*E[i]-ACNodeMatrix[i][i].X*F[i];		//N矩阵
				m_EquationCalcul.SetParam((i-1)*2,(i-1)*2+1,Nii);
				if (m_PQNodes[i].Category==PowerNode_PQ_Category||m_PQNodes[i].Category==PowerNode_PQD_Category||m_PQNodes[i].Category==PowerNode_PQL_Category)				//是否采用PQ节点算法
				{
					double Jii= ACNodeMatrix[i][i].R*E[i]-ai+ACNodeMatrix[i][i].X*F[i];//J矩阵，P26，公式（3-45）
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2,Jii);
					double Lii= bi+ACNodeMatrix[i][i].X*E[i]-ACNodeMatrix[i][i].R*F[i];//L矩阵，P26，公式（3-45）
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2+1,Lii);
				}
				else if (m_PQNodes[i].Category==PowerNode_PV_Category)													//PV节点的判断
				{
					double Rii=-2*F[i];
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2,Rii);
					double Sii=-2*E[i];
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2+1,Sii);
				}
				else if (m_PQNodes[i].Category==PowerNode_PH_Category)													//PH节点的判断
				{
					m_EquationCalcul.SetParam((i-1)*2,(i-1)*2,0);
					m_EquationCalcul.SetParam((i-1)*2,(i-1)*2+1,0);
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2,0);
					m_EquationCalcul.SetParam((i-1)*2+1,(i-1)*2+1,0);
				}
			}
			else//i不等于j时，矩阵的产生方法
			{
				double Hij=ACNodeMatrix[i][j].X*E[i]-ACNodeMatrix[i][j].R*F[i];//H矩阵，P26，公式（3-44）
				m_EquationCalcul.SetParam((i-1)*2,(j-1)*2,Hij);
				double Nij =-ACNodeMatrix[i][j].R*E[i]-ACNodeMatrix[i][j].X*F[i];//N矩阵，P26，公式（3-44）
				m_EquationCalcul.SetParam((i-1)*2,(j-1)*2+1,Nij);

				if (m_PQNodes[i].Category==PowerNode_PQ_Category||m_PQNodes[i].Category==PowerNode_PQD_Category||m_PQNodes[i].Category==PowerNode_PQL_Category)
				{
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2,-Nij);
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2+1,Hij);
				}
				else if (m_PQNodes[i].Category==PowerNode_PV_Category)
				{
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2,0);
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2+1,0);
				}
				else if (m_PQNodes[i].Category==PowerNode_PH_Category)
				{
					m_EquationCalcul.SetParam((i-1)*2,(j-1)*2+1,0);
					m_EquationCalcul.SetParam((i-1)*2,(j-1)*2,0);
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2,0);
					m_EquationCalcul.SetParam((i-1)*2+1,(j-1)*2+1,0);
				}
			}
		}
		m_EquationCalcul.SetParam((i-1)*2,2*m_PQNodes.size()-2,P[i]);
		m_EquationCalcul.SetParam((i-1)*2+1,2*m_PQNodes.size()-2,Q[i]);
	}
	//TRACE("E0%f,f0%f\n",E[0],F[0]);
	//TRACE("E1%f,f1%f\n",E[1],F[1]);
	return true;
}

double ACSysMG::CalPiValue(int i)//第i个节点的功率值计算，计算有功功率的值
{
	double sume=0;
	double sumf=0;
	if (i < m_nMaxSigleArrowTrainNums && i < m_PQNodes.size())
	{
		for (int k=0;k<m_PQNodes.size();k++)
		{
			sume+=(ACNodeMatrix[i][k].R*E[k]-ACNodeMatrix[i][k].X*F[k]);//Pi值的实部计算，P25，公式（3-41）
			sumf+=(ACNodeMatrix[i][k].R*F[k]+ACNodeMatrix[i][k].X*E[k]);//Pi值的虚部计算，P25，公式（3-41）
		}	
	}
	double a;
	a=E[i]*sume+F[i]*sumf;
	return E[i]*sume+F[i]*sumf;

}
void ACSysMG::GetPQIPublishLine(std::vector<POWERVALUE>& PQIList)//获取有功、无功功率，电流的值
{
	for(int n=1;n<m_PQNodes.size();n++)
	{
		for (int e=0;e<m_PQNodes[n].m_SubLines.size();e++)
		{		
			//		if (m_PQNodes[n].Category == PowerNode_PQD_Category)
			{
				POWERVALUE eqpmtupdata;
				eqpmtupdata.StationID = m_PQNodes[n].StationID;
				eqpmtupdata.InputI=	m_PQNodes[n].m_SubLines[e].I;//获取子线节点数据信息
				eqpmtupdata.P = m_PQNodes[n].m_SubLines[e].P;
				eqpmtupdata.Q = m_PQNodes[n].m_SubLines[e].Q;
				eqpmtupdata.EqpmtID=m_PQNodes[n].m_SubLines[e].breakerid;
				eqpmtupdata.Parm=m_PQNodes[n].m_SubLines[e].type;
				eqpmtupdata.SubLineID=m_PQNodes[n].m_SubLines[e].tranformid;
				eqpmtupdata.Position = m_PQNodes[n].Position;
				eqpmtupdata.V =  m_PQNodes[n].OutputV*Vac;
				PQIList.push_back(eqpmtupdata);
			}
		}
	}
}
void ACSysMG::GetMLVPublish(std::vector<POWERVALUE>& PQIList)//获取母线电压
{
	for(int n=0;n<m_PQNodes.size();n++)
	//for(int n=1;n<m_PQNodes.size();n++)
	{
		//	if (m_PQNodes[n].Category == PowerNode_PQD_Category)
		{
			POWERVALUE eqpmtupdata;
			eqpmtupdata.StationID = m_PQNodes[n].StationID;
			eqpmtupdata.MLineID=m_PQNodes[n].BgkID;
			eqpmtupdata.V = m_PQNodes[n].OutputV*Vac;
			eqpmtupdata.Position = m_PQNodes[n].Position;
			PQIList.push_back(eqpmtupdata);      
		}
	}
}
void ACSysMG::GetIPublishLine(std::vector<POWERVALUE>& PQIList) //获取电流
{
	for(int n=1;n<m_PQNodes.size();n++)
	{
		//	if (m_PQNodes[n].Category == PowerNode_PQD_Category)
		{
			POWERVALUE eqpmtupdata;
			eqpmtupdata.StationID = m_PQNodes[n].StationID;
			eqpmtupdata.MLineID=m_PQNodes[n].BgkID;
			eqpmtupdata.InputI = m_PQNodes[n].InputI;
			eqpmtupdata.InputLineID = m_PQNodes[n].inputlineid;
			eqpmtupdata.OutputI = m_PQNodes[n].OutputI;
			eqpmtupdata.OutLineID = m_PQNodes[n].outputlineid;
			eqpmtupdata.Parm = m_PQNodes[n].Category;///
			eqpmtupdata.Position = m_PQNodes[n].Position;
			PQIList.push_back(eqpmtupdata);  
		}
	}
	// 	EnterCriticalSection(&m_CritilSecEqpmt);
	// 	ACSysMG::EqpmtMap::iterator iter = m_EqpmtInfoMap.begin();
	// 	for (;iter!=m_EqpmtInfoMap.end();iter++)
	// 	{
	// 		EqpmtInfo* peqpmt = iter->second;
	// 		if (peqpmt->GetCateGory()==Eqpmt_Category_Powerline)
	// 		{
	// 			PowerLine* pLine = (PowerLine*)iter->second;
	// 			if (pLine->GetBgkLineID()>0)
	// 			{
	// 				POWERVALUE eqpmtupdata;
	// 				eqpmtupdata.I=	pLine->GetLineI();
	// 				eqpmtupdata.ID= pLine->GetBgkLineID();
	// 				PQIList.push_back(eqpmtupdata);
	// 			}
	// 		}
	// 	}
	// 	LeaveCriticalSection(&m_CritilSecEqpmt);
}
void ACSysMG::InitData()
{
	for (int i=0;i < m_nMaxSigleArrowTrainNums;i++)
	{
		if (i<m_PQNodes.size())
		{
			E[i]=m_PQNodes[i].E;
			F[i]=m_PQNodes[i].F;
		}
		P[i]=0;
		Q[i]=0;
	}
	CalNodePowerRate();//计算节点功率
	CalStatus=false;
}

bool ACSysMG::RunCalValue()				//动态计算相关电力值，在此涉及到交流侧的所有计算
{
	InitData();
	for (int i=0;i<Max_Cal_Times;i++)
	{
		CalPQValue();				//计算有功、无功功率  
		CreateYKBMatrix();			//生成雅可比矩阵
		if (CalYKBMatriX())			//雅可比矩阵的计算
		{
			CalResult();			//计算节点的电压、功率、电流、消耗功率的有功功率的输入输出电流、无功功率的输入输出电流
			ELEEQPMTMAP::iterator haha=m_pElectricEqpmtMap->find("{950E7D94-13BA-45B9-9740-BA37DDF86251}");
			CalStatus=true;
			break;
		}
	}
	return CalStatus;
	//return true;
}

double ACSysMG::GetOutV(int i)//获致对应节点的输出电压
{
	if (CalStatus&&i>=0&&i<m_PQNodes.size())//CalStatus计算状态标志位
	{	
		return m_PQNodes[i].OutputV;
	}
	return -1;
}
void  ACSysMG::SetYBZ(double i,double z,double y,double s,double v)//设置电力参数（电流，电抗，视载功率，电压）
{
	Iac = i;
	Zac = z;
	Yac = y;
	Sac = s;
	Vac = v;
}
//
void ACSysMG::CalNodePowerRate()					//计算节点功率->根据直流侧的功率来计算交流侧的功率
{
	for (int i=1;i<m_PQNodes.size();i++)
	{
		for (int e=0;e< m_nAllPowerStationNums;e++)
		{
			if (m_PQNodes[i].StationID==p_PQValueArr[e].StationID&&m_PQNodes[i].Category==PowerNode_PQD_Category)
			{//直流节点与交流节点的ID是否相同与交流侧计算方法的判断，根据直流侧的功率来计算交流侧的功率
				double a=p_PQValueArr[e].P_QY;
				double b=p_PQValueArr[e].Q_QY;
				m_PQNodes[i].ConsumePowerR=p_PQValueArr[e].P_QY/Sac;//消耗功率的实部
				m_PQNodes[i].ConsumePowerX=p_PQValueArr[e].Q_QY/Sac;//虚部

				for (int k = 0;k<m_PQNodes[i].m_SubLines.size();k++)
				{
					if (m_PQNodes[i].m_SubLines[k].type==1)     //输电线路
					{
						m_PQNodes[i].m_SubLines[k].P=p_PQValueArr[e].P_QY/2;
						m_PQNodes[i].m_SubLines[k].Q=p_PQValueArr[e].Q_QY/2;
					}
				}

// 线程安全的时间获取方式
				auto now = std::chrono::system_clock::now();
				std::time_t now_time = std::chrono::system_clock::to_time_t(now);
				std::tm local_time;
#if defined(_WIN32)
				localtime_s(&local_time, &now_time);
#else
				localtime_r(&now_time, &local_time);
#endif
				int current_hour = local_time.tm_hour;

				// 使用当前小时进行累加
				p_PQValueArr[e].P_QYSum[current_hour] += p_PQValueArr[e].P_QY / 360000000;//主站有功功率和
				p_PQValueArr[e].Q_QYSum[current_hour] += p_PQValueArr[e].Q_QY / 360000000;//主站无功功率和
				p_PQValueArr[e].P_HKSum[current_hour] += p_PQValueArr[e].P_HK / 360000000;//副站有功功率和
				p_PQValueArr[e].Q_HKSum[current_hour] += p_PQValueArr[e].Q_HK / 360000000;//副站无功功率和

				p_PQValueArr[e].P_QY=0;//主站有功功率
				p_PQValueArr[e].Q_QY=0;
			}
		}
	}	
}
double ACSysMG::CalPQValue()									//计算有功、无功功率  
{
	for (int i=0;i<m_PQNodes.size();i++)
	{
		double s=CalPiValue(m_PQNodes[i].Index);
		P[i]=m_PQNodes[i].Pis-s/*-m_PQNodes[i].ConsumePowerR*/;//P28 (3-41) (3-42)，得到有功功率偏差向量
		if (m_PQNodes[i].Category==PowerNode_PQ_Category||m_PQNodes[i].Category==PowerNode_PQD_Category||m_PQNodes[i].Category==PowerNode_PQL_Category)//PQ节点方法算无功功率
		{
			Q[i]=m_PQNodes[i].Qis-CalQiValue(m_PQNodes[i].Index)/*-m_PQNodes[i].ConsumePowerX*/;//P28 (3-41) (3-42)，得到无功功率偏差向量
		}
		else if (m_PQNodes[i].Category==PowerNode_PH_Category)//PH节点方法算有功、无功功率
		{
			P[i]=0;
			Q[i]=0;
			E[i]=m_PQNodes[i].E;
			F[i]=m_PQNodes[i].F;
		}
	}
	//TRACE("E0%f,f0%f\n",E[0],F[0]);
	//TRACE("E1%f,f1%f\n",E[1],F[1]);
	return 0;
}

bool ACSysMG::CreatePQNodeMatrix()					//生成交流侧PQ节点矩阵 ，交流节点矩阵ACNodeMatrix  的产生方法，  //生成节点导纳矩阵 xyx注释
{

	for (int k=0;k< m_nMaxSigleArrowTrainNums;k++)
	{
		for (int j=0;j< m_nMaxSigleArrowTrainNums;j++)
		{
			//节点导纳矩阵初始化 xyx注释
			ACNodeMatrix[k][j].R=0;					//交流PQ节点矩阵初始化
			ACNodeMatrix[k][j].X=0;
		}	
	}
	for (int i=0;i<m_PQNodes.size();i++)  //第i个节点
	{
		if (m_PQNodes[i].ID>=0)
		{
			for (int j=0;j<m_PQNodes[i].m_Relations.size();j++)   //与节点i相关连支路j xyx注释
			{
				EqpmtMap::iterator iter = m_EqpmtInfoMap.find(m_PQNodes[i].m_Relations[j]);   //根据支路数据设置节点导纳 xyx注释
				if (iter!=m_EqpmtInfoMap.end())
				{
					PowerLine* pLine= (PowerLine*)iter->second;

					if (pLine->GetStatus()==0)
					{
						continue;
					}

					double r = pLine->GetR();     //支路设置r、x、b
					double x = pLine->GetX();
					double b = pLine->GetB(); 
					int otherindex=-1;
					int index =m_PQNodes[i].Index;
					
					if (index==111)
					{
						int a=0;
					}
					else if (index==112)
					{
						int b=0;
					}


					if (m_PQNodes[i].Index >= 0 && m_PQNodes[i].Index < m_nMaxSigleArrowTrainNums)
					{
						//当前节点i处于支路ij的末端 xyx注释
						if (m_PQNodes[i].Index!=pLine->GetLlineID())
						{
							if (m_PQNodes[i].Index==pLine->GetRlineID())
							{
								otherindex=pLine->GetLlineID();
							}
						}
						//当前节点i处于支路ij的首端 xyx注释
						else if (m_PQNodes[i].Index!=pLine->GetRlineID())  
						{
							otherindex=pLine->GetRlineID(); 
						}
						if (otherindex>=0)
						{
							if (otherindex >= 0 && otherindex < m_nMaxSigleArrowTrainNums)
							{
								//if (pLine->GetTransformID()>0)
								//{
								//	EqpmtMap::iterator iter1 = m_EqpmtInfoMap.find(pLine->GetTransformID());
								//	Transform* ptransform =(Transform* )iter1->second;
								//	double TransformRate =ptransform->GetRate();
								//	ACNodeMatrix[m_PQNodes[i].Index][otherindex].R = -r/((r*r+x*x)*TransformRate);		//阻抗实部的计算	 电阻
								//	ACNodeMatrix[m_PQNodes[i].Index][otherindex].X =  x/((r*r+x*x)*TransformRate);		//阻抗虚部的计算	 电抗
								//	if (ptransform->GetHead()==m_PQNodes[i].ID)
								//	{
								//		ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += r/(r*r+x*x);
								//		ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-x/(r*r+x*x)+b/2;
								//	}
								//	else
								//	{
								//		ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += r/((r*r+x*x)*TransformRate*TransformRate);
								//		ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-x/((r*r+x*x)*TransformRate*TransformRate)+b/2;
								//	}
								//}
				
								//情形1：若支路为变压器支路 xyx注释
								//若两节点i、j间为变压器支路，首端i为1侧，末端j为k侧，阻抗z=r+jx放在1侧
								//则节点间（1）互导Yij=Yji= -1/(kz)，（2）节点i自导Yii=1/z，（3）节点j自导Yjj=1/(k*k*z)
								if (pLine->GetCateGory()==Eqpmt_Category_Powerline_Transformer_35To400)
								{
									double R=11.4;
									double X=63.7;
									double K=0.0114;

									//ACNodeMatrix[m_PQNodes[i].Index][otherindex].R = -r/((r*r+x*x)*1);		//阻抗实部的计算	 电阻
									//ACNodeMatrix[m_PQNodes[i].Index][otherindex].X =  x/((r*r+x*x)*1);		//阻抗虚部的计算	 电抗

									//if (pLine->GetLlineID()==m_PQNodes[i].ID)
									//{
									//	ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += r/(r*r+x*x);
									//	ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-x/(r*r+x*x)+b/2;
									//}
									//else
									//{
									//	ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += r/((r*r+x*x)*1*1);
									//	ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-x/((r*r+x*x)*1*1)+b/2;
									//}
									
									//节点间的互导Yij=Yji= -1/(kz)
									ACNodeMatrix[m_PQNodes[i].Index][otherindex].R = -R/((R*R+X*X)*K);		//阻抗实部的计算	 电阻
									ACNodeMatrix[m_PQNodes[i].Index][otherindex].X =  X/((R*R+X*X)*K);		//阻抗虚部的计算	 电抗
									//情形1-1：若当前节点i处于变压器支路首端i（即变压器1侧）,则节点i的自导Yii=1/z
									if (pLine->GetLlineID()==m_PQNodes[i].ID)
									{
										ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += R/(R*R+X*X);
										ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-X/(R*R+X*X)+b/2;
									}
									//情形1-2：若当前节点i处于变压器末端j（即变压器k侧），则节点i的自导Yii=1/(k*k*z)
									else
									{
										ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].R += R/((R*R+X*X)*K*K);
										ACNodeMatrix[m_PQNodes[i].Index][m_PQNodes[i].Index].X +=-X/((R*R+X*X)*K*K)+b/2;
									}
								}
								//情形2：若支路为其他类型支路 xyx注释
								else
								{
									//ACNodeMatrix[m_PQNodes[i].Index][otherindex].R = -r/(r*r+x*x);
									//ACNodeMatrix[m_PQNodes[i].Index][otherindex].X =  x/(r*r+x*x);
									ACNodeMatrix[m_PQNodes[i].Index][otherindex].R = -r/(r*r+x*x);   //互导Yij
									ACNodeMatrix[m_PQNodes[i].Index][otherindex].X =  x/(r*r+x*x);
									ACNodeMatrix[index][index].R += r/(r*r+x*x);                     //自导Yii
									ACNodeMatrix[index][index].X +=-x/(r*r+x*x)+b/2;
								}
							}
						}
					}	
				}
			}
		}
	}
	return true;
}