#include "pch.h"
#include "DCSysMG.h"
#include <fstream>
#include <string>
#include <iomanip>

constexpr auto RAILWAY_DISTANCE_ALLEXCURSION = -1;

DCSysMG::DCSysMG(void)
{
	p_PQValueArr=nullptr;
	NodeIDsCount=1000;
	NodeIndex=0;

	m_nMaxSigleArrowTrainNums = Max_SigleArrowTrain_Nums;
	m_nAllPowerStationNums = All_Power_Station_Nums;
//	m_bInit = false;
}
void DCSysMG::ExitInstance()
{
	m_PowerStationNodeMap.clear();
	TrainSInStationMap.clear();
	m_NetTracksRelationMap.clear();
	m_TouchNetSpanNetInfo.clear();
	m_StationDataList.clear();				//车站信息
	m_RunDataList.clear();					//行车运行信息
	m_StationInfoVector.clear();
	m_DCFixNodesMap.clear();				//直流固定节点表
	m_DownFixRunDataList.clear();
	m_ShortCutAreaTrians.clear();
	m_DCNodesMap.clear();
	TouchNetMap.clear();
	p_PQValueArr=nullptr;
}
DCSysMG::~DCSysMG(void)
{
	ExitInstance();
}
void DCSysMG::SetPQValueArr(DCNodePQValue PQValueArr[])				//、设置直流PQ矩阵的值，其中包括直流的相关的计算
{
	p_PQValueArr=PQValueArr;
}
void DCSysMG::SetRunStatus(int status)								//设置运行状态
{
	m_RunStatus = status;
}

size_t DCSysMG::GetStationSize()
{
	return m_StationDataList.size();
}
bool DCSysMG::GetStationByindex(int index,TrainRuningData &station)	//根据索引、车站信息列表获取对应的车站信息
{
	if (index>=0&&index<m_StationDataList.size())
	{
		station = m_StationDataList[index];
		return true;
	}
	return false;
}
void DCSysMG::AddStationData(TrainRuningData &station)				//添加车站数据
{
	m_StationDataList.push_back(station);
}
void DCSysMG::AddStationInfo(Dc_PowerStation& station)				//添加车站信息，车站ID与车站名
{
	m_PowerStationNodeMap.insert(make_pair(station.GetID(),station));	
}
void DCSysMG::AddStationTo(int index,TrainRuningData &station)     ///增加车站信息到车站数据表，在对应的索引上添加车站信息
{
	m_StationDataList.insert(m_StationDataList.begin()+index,station);
}
int DCSysMG::CreateNodeID()										//生成节点的ID号
{
	NodeIDsCount++;
	DCYSNODEMAP::iterator iter = m_DCFixNodesMap.find(NodeIDsCount);
	if (iter!=m_DCFixNodesMap.end())
		return -1;
	else
		return NodeIDsCount;

}
void DCSysMG::AdjustTouchNetRelation(string touchnetid,Track_Section& tracksec)//根据接触网ID和轨道区段调整接触网与轨道的关系
{
	TOUCHNETRELAMAP::iterator iter = m_NetTracksRelationMap.find(touchnetid);
	if (iter!=m_NetTracksRelationMap.end())
	{
		iter->second.TrackSecsMap.insert(make_pair(tracksec.TrackID,tracksec));		//在对应信息列表中找到对应的touchnetid，则将tracksec与touchnetid关联
		//make_pair():creates a pair structure that contains two data elements of any type
	}
	else					//在对应信息列表中未找到对应的touchnetid，则新建一个touchnetid节点再将tracksec与touchnetid关联
	{
		TouchNet_Track_Relation touchrelation;
		touchrelation.TouchNetID = touchnetid;
		touchrelation.TrackSecsMap.insert(make_pair(tracksec.TrackID,tracksec));
		m_NetTracksRelationMap.insert(make_pair(touchnetid,touchrelation));
	}
}
double DCSysMG::GetTouchNetDurDistance(string startline,double exs,string endline,double exe,int arrow)//获取接触网的距离信息
{
	double len=0;
	string curtouchnet = startline;    
	if (startline==endline)   //若站间只由一段接触网组成，且当前接触网只对应一段轨道区段 xyx注释
	{
		len=exe-exs;							//终点与起点之差（一个区段的长度）
	}
	TOUCHNETMAP::iterator iterstart = TouchNetMap.find(startline);
	while(iterstart!=TouchNetMap.end()&&iterstart->first!=endline)		//起点与终点不重合     //若站间由多段接触网组成，且各段接触网对应多段轨道区段 xyx注释
	{
		if (iterstart->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
		{
			CElectricEqpmt_Line_TouchNet* pnet = iterstart->second;
			len+=GetTouchLenght(pnet->GetEqpmentID());							//获取接触网的长度
			iterstart = TouchNetMap.find(pnet->GetNextTouchNet());
		}
	}
	return len;
}
void DCSysMG::SetHeadTailTouchNet(int arrow,int headtail,string id)			///设置接触网的头尾点
{
	if (arrow==TRAIN_DIR_DOWN)//列车下行运行方向
	{
		if (headtail==TRAIN_DIR_HEAD)
		{
			DownStartTouchNetID=id;
		}
		else if (headtail==TRAIN_DIR_TAIL)
		{
			DownEndtouchNetID =id;
		}
	}
	else if (arrow==TRAIN_DIR_UP)
	{
		if (headtail==TRAIN_DIR_HEAD)
		{
			UpStartTouchNetID=id;
		}
		else if (headtail==TRAIN_DIR_TAIL)
		{
			UpEndTouchNetID =id;
		}
	}
}
bool DCSysMG::CreateTailNodes()			//尾节点的生成并对其初始化
{
	//上行轨道尾节点 xyx注释
	UpTailNodeID = CreateNodeID();		//上行尾节点
	if (UpTailNodeID<0)
	{
		return false;
	}
	HEADTAIL Node3;
	Node3.Init(NodeIndex,UpTailNodeID,Dc_NodeKind_UPTail);
	NodeIndex++;
	POWERNODE PowerNode3;			//电力节点
	PowerNode3.setHeadTail(&Node3);	//尾节点与电力节点关联
	m_DCFixNodesMap.insert(make_pair(UpTailNodeID,PowerNode3));		//将生成的电力节点添加到固定节点列表中

	//下行轨道尾节点 xyx注释
	DownTailNodeID = CreateNodeID();
	if (DownTailNodeID<0)
	{
		return false;
	}
	HEADTAIL Node4;
	Node4.Init(NodeIndex,DownTailNodeID,Dc_NodeKind_DownTail);
	NodeIndex++;
	POWERNODE PowerNode4;
	PowerNode4.setHeadTail(&Node4);
	m_DCFixNodesMap.insert(make_pair(DownTailNodeID,PowerNode4));
	
	return true;
}
void DCSysMG::PushTailNodes()					//保存节点数据
{
	LineNodeData nodeup;						//上行线节点数据
	nodeup.ID = UpTailNodeID;
	nodeup.Kind = Dc_NodeKind_UPTail;
	nodeup.TouchNetID = UpEndTouchNetID;
	nodeup.excursion = GetTouchLenght(UpEndTouchNetID);
	m_UpRunFixDataList.push_back(nodeup);

	LineNodeData nodedown;						//下行线节点数据
	nodedown.ID = DownTailNodeID;
	nodedown.Kind = Dc_NodeKind_DownTail;
	nodedown.TouchNetID = DownEndtouchNetID;
	nodedown.excursion = GetTouchLenght(DownEndtouchNetID);
	m_DownFixRunDataList.push_back(nodedown);
}
bool DCSysMG::CreateHeadNodes()					//生成头节点，并初始化头节点数据(类似于CreateTailNodes、PushTailNodes两函数的功能)
{
	//上行轨道头节点 xyx注释
	UpHeadNodeID = CreateNodeID();
	if (UpHeadNodeID<0)
	{
		return false;
	}
	HEADTAIL Node1;
	Node1.Init(NodeIndex,UpHeadNodeID,Dc_NodeKind_UPHead);
	NodeIndex++;
	POWERNODE PowerNode1;
	PowerNode1.setHeadTail(&Node1);
	m_DCFixNodesMap.insert(make_pair(UpHeadNodeID,PowerNode1));

	//下行轨道头节点 xyx注释
	DownHeadNodeID = CreateNodeID();
	if (DownHeadNodeID<0)
	{
		return false;
	}
	HEADTAIL Node2;
	Node2.Init(NodeIndex,DownHeadNodeID,Dc_NodeKind_DownHead);
	NodeIndex++;
	POWERNODE PowerNode2;
	PowerNode2.setHeadTail(&Node2);
	m_DCFixNodesMap.insert(make_pair(DownHeadNodeID,PowerNode2));

	//上行接触网头节点 xyx注释
	LineNodeData nodeup;
	nodeup.ID = UpHeadNodeID;
	nodeup.Kind = Dc_NodeKind_UPHead;
	nodeup.TouchNetID = UpStartTouchNetID;
	nodeup.excursion = 0;
	m_UpRunFixDataList.push_back(nodeup);

	//下行接触网头节点 xyx注释
	LineNodeData nodedown;
	nodedown.ID = DownHeadNodeID;
	nodedown.Kind = Dc_NodeKind_DownHead;
	nodedown.TouchNetID = DownStartTouchNetID;
	nodedown.excursion = 0;
	m_DownFixRunDataList.push_back(nodedown);

	return true;
}
bool DCSysMG::AddSpanNetInfo(int station,int errorid,int arrow)				//增加跨网信息
{
	m_CritilSecSpanNet.lock();
	TouchNet_SpanNetApplyPower_Info span;			//接触网跨网供电信息
	span.arrow=arrow;
	span.errorid=errorid;
	span.stationid = station;

	DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.find(station);
	if (iter == m_PowerStationNodeMap.end())
	{
		m_CritilSecSpanNet.unlock();
		return false;
	}

	span.nodeid = iter->second.GetRectierToTouchNetNodeID();
	m_TouchNetSpanNetInfo.push_back(span);
	m_CritilSecSpanNet.unlock();

	return true;
}
bool DCSysMG::RemoveSpanNetInfo(int station,int errorid,int arrow)			//删除跨网信息
{
	bool ret=false;
	m_CritilSecSpanNet.lock();
	for (size_t i=0;i<m_TouchNetSpanNetInfo.size();i++)
	{
		if (m_TouchNetSpanNetInfo[i].stationid=station&& arrow == m_TouchNetSpanNetInfo[i].arrow)
		{
			m_TouchNetSpanNetInfo.erase(m_TouchNetSpanNetInfo.begin()+i);
			ret=true;
			break;	
		}
	}
	m_CritilSecSpanNet.unlock();

	return ret;
}
bool DCSysMG::CreateRectierToTouchNetNode(Dc_PowerStation& Station)		//生成整流器到接触网节点，并对其初始化   
{
	//创建直流正极母线节点 xyx注释
	RECTIERTOTOUCHNET Node;
	int NodeID = CreateNodeID();
	if (NodeID<0)
		return false;
	
	POWERNODE PowerNode;										//电节点定义及其初始化
	ELEEQPMTMAP::iterator iterRectierToTouchNet =ElectricEqpmtMap.find(Station.GetRectierToTouchNetUnitID());
	if (iterRectierToTouchNet!=ElectricEqpmtMap.end())
	{
		if (!iterRectierToTouchNet->second->GetPower())
		{
			Node.SetPower(false);
			//PowerNode.m_NodeV=0.0;
		}
	}

	Node.Init(NodeIndex,NodeID,Dc_NodeKind_RectierToTouchNet);
	NodeIndex++;
	Node.StationID = Station.GetID();									//将车站ID设置为整流器到接触网的ID
	Station.SetRectierToTouchNetNodeID(NodeID);							//将整流器到接触网的ID设置为车站的ID
	Node.SetTouchLineLen(Station.GetUpPreLineLen(),Station.GetDownPreLineLen(),Station.GetUpNextLineLen(),Station.GetDownNextLineLen());	//设置接触网的长度
	//整流器到接触网的节点，应有上行与下行，在这里为什么只创建一个节点，但是在后面创建了上下行节点，其上下行节点ID均为NodeID，实现原理？

	double upprenodelinelen;    //当前站上行前一节点接触网长度（上行：前一站与当前站间的接触网长度） xyx注释
	double downprenodelinelen;  //当前站下行前一节点接触网长度（下行：前一站与当前站间的接触网长度） xyx注释

	//设置当前站与前一站间直流正极母线节点的相关信息 xyx注释
	DCSTATIONMAP::iterator iter1=m_PowerStationNodeMap.find(Station.GetPreStationID());			//获取Station前一车站的ID
	int n5 = Station.GetPreStationID();
	if (iter1!=m_PowerStationNodeMap.end())
	{
		upprenodelinelen = GetTouchNetDurDistance(iter1->second.GetUpTouchNetID(),0,Station.GetUpTouchNetID(),0,TRAIN_DIR_UP);	//获取Station前一车站对应的上行接触网的长度
		downprenodelinelen = GetTouchNetDurDistance(iter1->second.GetDownTouchNetID(),0,Station.GetDownTouchNetID(),0,TRAIN_DIR_DOWN);	//获取Station前一车站对应的下行接触网的长度

		DCYSNODEMAP::iterator iter2 = m_DCFixNodesMap.find(iter1->second.GetRectierToTouchNetNodeID());	//获取Station前一车站对应的整流器到接触网的ID
		if (iter2!=m_DCFixNodesMap.end())
		{
			POWERNODE& PowerNode = iter2->second;
			PowerNode.RectierToTouchNetNode.SetUpNextNode(NodeID,upprenodelinelen,Node.GetPower());	    //将当前站的直流正极母线作为前一站的上行后一节点，并赋予节点编号及接触网长度 xyx注释
			PowerNode.RectierToTouchNetNode.SetDownNextNode(NodeID,downprenodelinelen,Node.GetPower());	//将当前站的直流正极母线作为前一站的下行后一节点，并赋予节点编号及接触网长度 xyx注释
		}
		else
			return false;

		Node.SetUpPreNode(iter1->second.GetRectierToTouchNetNodeID(),upprenodelinelen,iter2->second.RectierToTouchNetNode.GetPower());		//将前一站的直流正极母线作为当前站的上行前一节点，并赋予节点编号及接触网长度 xyx注释
		Node.SetDownPreNode(iter1->second.GetRectierToTouchNetNodeID(),downprenodelinelen,iter2->second.RectierToTouchNetNode.GetPower()); //将前一站的直流正极母线作为当前站的下行前一节点，并赋予节点编号及接触网长度 xyx注释
	}

	//将当前车站的直流正极母线节点作为上行接触网节点添加至上行固定节点m_UpRunFixDataList中 xyx注释
	LineNodeData nodeup;									//整流器到上行接触网的节点         上行接触线节点数据及其初始化
	nodeup.ID = NodeID;
	nodeup.Kind = Dc_NodeKind_RectierToTouchNet;
	nodeup.TouchNetID = Station.GetUpTouchNetID();
	nodeup.excursion = 0;
	m_UpRunFixDataList.push_back(nodeup);					//节点信息添加到上行固定节点列表信息中
	
	//将当前车站的直流正极母线节点作为下行接触网节点添加至下行固定节点m_DownFixRunDataList中 xyx注释
	LineNodeData nodedown;									//整流器到下行接触网的节点
	nodedown.ID = NodeID;
	nodedown.Kind = Dc_NodeKind_RectierToTouchNet;
	nodedown.TouchNetID = Station.GetDownTouchNetID();
	nodedown.excursion = 0;
	m_DownFixRunDataList.push_back(nodedown);

	//将当前车站的直流正极母线节点添加至POWERNODE及直流固定节点m_DCFixNodesMap中 xyx注释
	PowerNode.setRectierToTouchNet(&Node);
	m_DCFixNodesMap.insert(make_pair(NodeID,PowerNode));		//再将整流器到接触网的节点添加到固定节点列表中
	//make_pair(*,*)其中的参数根据调用对像进行确定，要求所传参数与调用对象一致，但是其中的参数比较灵活
	return true;
}
bool DCSysMG::CreateRectierToRailWayNode(Dc_PowerStation& Station)			//生成整流器到轨道节点并对其进行初始化
{
	RECTIERTORAILWAY pNode;													//整流器到轨道节点  //根据程序及图例推理：此节点为整流器节点（2016.03.18），根据字面理解就是一个坑啊
	int NodeID = CreateNodeID();
	if (NodeID<0)
		return false;
	
	POWERNODE PowerNode;										//电节点定义及其初始化
	ELEEQPMTMAP::iterator iterRectierToRailway =ElectricEqpmtMap.find(Station.GetRectierToRailwayUnitID());
	if (iterRectierToRailway!=ElectricEqpmtMap.end())
	{
		if (!iterRectierToRailway->second->GetPower())
		{
			pNode.SetPower(false);
			//PowerNode.m_NodeV=0.0;
		}
	}

	pNode.Init(NodeIndex,NodeID,Dc_NodeKind_RectierToRailWay);
	NodeIndex++;
	pNode.StationID=Station.GetID();
	Station.SetRectierToRailwayNodeID(NodeID);
	//pNode.SetInnerNode(Station.GetRectierToTouchNetNodeID(),Station.GetInnerR());		   //将当前站的直流正极母线节点作为负极母线节点的内节点并赋予内阻参数 xyx注释
	pNode.SetFeedBackLineLen(Station.GetUpFeedBackLineLen(),Station.GetDownFeedBackLen()); //将当前站的2条回流线长度赋给负极母线节点的回流线 xyx注释

	DCYSNODEMAP::iterator iter2 = m_DCFixNodesMap.find(Station.GetRectierToTouchNetNodeID());		//在固定节点列表中查找Station车站的整流器到接触网的节点是否存在
	if (iter2!=m_DCFixNodesMap.end())
	{
		POWERNODE& PowerNode = iter2->second;
		PowerNode.RectierToTouchNetNode.SetInnerNode(NodeID,Station.GetInnerR(),pNode.GetPower());  //将当前站的直流负极母线节点作为正极母线节点的内节点并赋予内阻参数 xyx注释
		pNode.SetInnerNode(Station.GetRectierToTouchNetNodeID(),Station.GetInnerR(),PowerNode.RectierToTouchNetNode.GetPower()); //将当前站的直流正极母线节点作为负极母线节点的内节点并赋予内阻参数 xyx注释
	}
	else
		return false;

	//将当前负极母线节点添加至POWERNODE及直流固定节点m_DCFixNodesMap中 xyx注释
	PowerNode.setRectierToRailway(&pNode);
	m_DCFixNodesMap.insert(make_pair(NodeID,PowerNode));

	return true;
}
bool DCSysMG::CreateRailWayNode(Dc_PowerStation& Station)	//	生成轨道节点并对其进行初始化   //根据程序及图例推理（2016.03.18）：此节点为整流器到轨道的节点（包括上行轨道节点、下行轨道节点）
{
	RAILWAY pUpNode;								//上行轨道节点
	int UpNodeID = CreateNodeID();
	if (UpNodeID<0)
		return false;
	pUpNode.Init(NodeIndex,UpNodeID,Dc_NodeKind_RailWay);
	NodeIndex++;
	pUpNode.StationID=Station.GetID();
	pUpNode.SetFeedBackLineLen(Station.GetUpFeedBackLineLen());
	Station.SetUpRailwayNodeID(UpNodeID);
	//将直流负极母线设为当前上行轨道节点的关联节点，并赋予上行回流线长度 xyx注释
	//pUpNode.SetRectierNode(Station.GetRectierToRailwayNodeID(),Station.GetUpFeedBackLineLen());	//根据程序及图例推理（2016.03.18）：将整流器节点设为上行轨道节点的关系节点

	RAILWAY pDownNode;							//下行轨道节点
	int DownNodeID = CreateNodeID();
	if (DownNodeID<0)
		return false;
	pDownNode.Init(NodeIndex,DownNodeID,Dc_NodeKind_RailWay);
	NodeIndex++;
	pDownNode.StationID=Station.GetID();
	pDownNode.SetFeedBackLineLen(Station.GetDownFeedBackLen());
	Station.SetDownRailwayNodeID(DownNodeID);
	//将直流负极母线设为当前下行轨道节点的关联节点，并赋予下行回流线长度 xyx注释
	//pDownNode.SetRectierNode(Station.GetRectierToRailwayNodeID(),Station.GetDownFeedBackLen());	//设置与下行轨道节点相关的参数信息

	DCYSNODEMAP::iterator iter = m_DCFixNodesMap.find(Station.GetRectierToRailwayNodeID());		//在车站信息列表中查找是否有Station车站的整流器到轨道的节点
	int n8 = Station.GetRectierToRailwayNodeID();
	if (iter!=m_DCFixNodesMap.end())  
	{
		POWERNODE& PowerNode = iter->second;
		PowerNode.RectierToRailwayNode.SetUpNode(UpNodeID,Station.GetUpFeedBackLineLen(),true);//将当前上行轨道节点设置为直流负极母线的关系节点，并赋予上行回流长度 xyx注释
		PowerNode.RectierToRailwayNode.SetDownNode(DownNodeID,Station.GetDownFeedBackLen(),true);//将当前下行轨道节点设置为直流负极母线的关系节点，并赋予下行回流长度 xyx注释
	    
		//xyx修改
		pUpNode.SetRectierNode(Station.GetRectierToRailwayNodeID(),Station.GetUpFeedBackLineLen(),PowerNode.RectierToRailwayNode.GetPower());	//根据程序及图例推理（2016.03.18）：将整流器节点设为上行轨道节点的关系节点
		pDownNode.SetRectierNode(Station.GetRectierToRailwayNodeID(),Station.GetDownFeedBackLen(),PowerNode.RectierToRailwayNode.GetPower());	//设置与下行轨道节点相关的参数信息
	}
	else
		return false;

	//设置前一站与当前站间的轨道长度 xyx注释
	double UpRailWayLen=0;
	double DownRailWayLen=0;
	
	if (Station.GetPreStationID()<=0)   //情形1：当前车站的PreStationID=0，则当前站为始端站，Table_DCStationInfo中参数：PreStationID  xyx注释
	{
		UpRailWayLen = GetTouchLenght(UpStartTouchNetID);		//获取起始接触网上行的长度  //将起始上行接触网的长度作为当前站上行轨道长度  xyx注释
		DownRailWayLen = GetTouchLenght(DownStartTouchNetID);	//获取起始接触网下行的长度  //将起始下行接触网的长度作为当前站下行轨道长度  xyx注释

		//将当前上行轨道节点设置为轨道头节点 xyx注释
		DCYSNODEMAP::iterator iter2 = m_DCFixNodesMap.find(UpHeadNodeID);//查找上行的头节点ID
		if (iter2!=m_DCFixNodesMap.end())
		{
			POWERNODE& PowerNode = iter2->second;
			PowerNode.HeadTailNode.SetDownNode(UpNodeID,UpRailWayLen,true);		//如找到上行头节点ID，则设置上行头节点的下一节点（此处应有误SetDownNode是否应为SetUpNode）			则将UpNodeID设为头节点
		}
		else
			return false;
		//将当前上行轨道节点的前一节点设置为其本身  xyx注释
		pUpNode.SetPreNode(UpHeadNodeID,UpRailWayLen,true);			//如Station没有前一车站，则设置上行轨道节点的前一节点信息

		//将当前下行轨道节点设置为轨道头节点 xyx注释
		DCYSNODEMAP::iterator iter4 = m_DCFixNodesMap.find(DownHeadNodeID);//查找下行头节点
		if (iter4!=m_DCFixNodesMap.end())
		{
			POWERNODE& PowerNode = iter4->second;
			PowerNode.HeadTailNode.SetDownNode(DownNodeID,DownRailWayLen,true);	//设置下行头节点的下一节点
		}
		else
			return false;
		//将当前下行轨道节点的前一节点设置为其本身  xyx注释
		pDownNode.SetPreNode(DownHeadNodeID,DownRailWayLen,true);	//如Station没有前一车站，则设置下行轨道节点的前一节点信息
	}
	
	else  //情形2：若当前站为中间站 xyx注释
	{
		DCSTATIONMAP::iterator iter1=m_PowerStationNodeMap.find(Station.GetPreStationID());//查找Station车站对应的前一车站ID
		if (iter1!=m_PowerStationNodeMap.end())
		{
			//将前一站与当前站间的上、下行接触网长度赋给相应的上、下行轨道 xyx注释
			UpRailWayLen = GetTouchNetDurDistance(iter1->second.GetUpTouchNetID(),0,Station.GetUpTouchNetID(),0,TRAIN_DIR_UP);	//获取Station车站与前一车站上行接触网之间的距离
			DownRailWayLen = GetTouchNetDurDistance(iter1->second.GetDownTouchNetID(),0,Station.GetDownTouchNetID(),0,TRAIN_DIR_DOWN);//获取Station车站与前一车站下行接触网之间的距离

			DCYSNODEMAP::iterator iter3 = m_DCFixNodesMap.find(iter1->second.GetUpRailwayNodeID());//查找Station前一车站的上行轨道节点
			if (iter3!=m_DCFixNodesMap.end())
			{
				POWERNODE& PowerNode = iter3->second;                     //前一车站上行轨道节点
				PowerNode.RailWayNode.SetNextNode(UpNodeID,UpRailWayLen,true); //将当前车站上行轨道节点设置为前一车站上行轨道节点的后一节点 xyx注释
				pUpNode.SetPreNode(PowerNode.NodeID,UpRailWayLen,true);        //将前一车站上行轨道节点设置为当前车站上行轨道节点的前一节点 xyx注释
			}
			else
				return false;

			DCYSNODEMAP::iterator iter5 = m_DCFixNodesMap.find(iter1->second.GetDownRailwayNodeID());//查找Station前一车站的下行轨道节点
			if (iter5!=m_DCFixNodesMap.end())
			{
				POWERNODE& PowerNode = iter5->second;                         //前一车站下行轨道节点
				PowerNode.RailWayNode.SetNextNode(DownNodeID,DownRailWayLen,true); //将当前车站下行轨道节点设置为前一车站下行轨道节点的后一节点 xyx注释
				pDownNode.SetPreNode(PowerNode.NodeID,DownRailWayLen,true);        //将前一车站下行轨道节点设置为当前车站下行轨道节点的前一节点 xyx注释
			}
			else
			{
				return false;
			}
				
		}
		else 
		{
				return false;
		}		
	}

	if (Station.GetNextStationID()<=0)  //情形3：当前车站的NextStationID=0，则当前站为末端站，Table_DCStationInfo中参数：NextStationID xyx注释
	{
		double upnextnodelinelen =  GetTouchLenght(UpEndTouchNetID);			//获取上行最后一个接触网的长度 //将末端上行接触网的长度作为当前站上行轨道长度  xyx注释
		double downnextnodelinelen = GetTouchLenght(DownEndtouchNetID);			//获取下行最后一个接触网的长度 //将末端下行接触网的长度作为当前站上行轨道长度  xyx注释

		DCYSNODEMAP::iterator iter2 = m_DCFixNodesMap.find(UpTailNodeID);		//查找上行尾节点是否在固定节点列表信息中
		if (iter2!=m_DCFixNodesMap.end())
		{
			POWERNODE& PowerNode = iter2->second;     //上行轨道尾节点
			PowerNode.HeadTailNode.SetDownNode(UpNodeID,upnextnodelinelen,true);	//设置尾节点的下行节点    		//将当前上行轨道节点设置为上行轨道尾节点 xyx注释
			pUpNode.SetNextNode(UpTailNodeID,upnextnodelinelen,true);			//设置上行节点的下一节点        //将当前上行轨道节点的下一节点设为设置为其本身 xyx注释
		}
		else
			return false;

		DCYSNODEMAP::iterator iter6 = m_DCFixNodesMap.find(DownTailNodeID);	//查找下行尾节点是否在固定节点列表信息中
		if (iter6!=m_DCFixNodesMap.end())
		{
			POWERNODE& PowerNode = iter6->second;     //下行轨道尾节点
			PowerNode.HeadTailNode.SetDownNode(DownNodeID,downnextnodelinelen,true);	//查找下行尾节点的下行节点   //将当前下行轨道节点设置为下行轨道尾节点 xyx注释
			pDownNode.SetNextNode(DownTailNodeID,downnextnodelinelen,true);			//设置下行节点的下一节点     //将当前下行轨道节点的下一节点设为设置为其本身 xyx注释
		}
		else
			return false;

	}
	//将当前上行轨道节点添加至PowerNode1的轨道节点中，及直流固定节点m_DCFixNodesMap中 xyx注释
	POWERNODE PowerNode1;
	PowerNode1.setRailway(&pUpNode);
	m_DCFixNodesMap.insert(make_pair(UpNodeID,PowerNode1));		//将上行节点添加到固定节点列表中

	//将当前下行轨道节点添加至PowerNode1的轨道节点中，及直流固定节点m_DCFixNodesMap中 xyx注释
	POWERNODE PowerNode2;
	PowerNode2.setRailway(&pDownNode);
	m_DCFixNodesMap.insert(make_pair(DownNodeID,PowerNode2));	//将下行节点添加到固定节点列表中

	return true;
}
bool DCSysMG::CreateTrainNode()					//生成列车节点并对其进行初始化	
{
	m_CritilSec.lock();
	vector<LineNodeData> m_UpRunDataList=m_UpRunFixDataList;
	vector<LineNodeData> m_DownRunDataList=m_DownFixRunDataList;
	NodeIndex=m_DCFixNodesMap.size();
	map<int,DCSysTrain>::iterator iter =TrainSInStationMap.begin();//DCSysTrain直流列车类，  //TrainSInStationMap 根据行调系统发送过来的列车运行信息，并根据其受电状态构建列车信息表 (2016.03.18)
	for (;iter!=TrainSInStationMap.end();iter++)  //TrainSInStationMap为在线上正常运行列车（受电弓有电）列表
	{
		//MOD BY YangS (add m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)//#define DISPATCH_RUN_STATUS_RUNNING				500
		{
			break;
		}
		AddTrainToNodes(iter->second,m_UpRunDataList,m_DownRunDataList);
	}
	m_CritilSec.unlock();
	return true;
}
string DCSysMG::GetTouchNetByPosition(int trackid,double ex)			//根据轨道ID号和偏移（长度）获取接触网的位置      //获取列车所在的接触网ID xyx注释
{
	TOUCHNETRELAMAP::iterator iter = m_NetTracksRelationMap.begin();
	for (;iter!=m_NetTracksRelationMap.end();iter++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return "";
		}
		TRACKSECMAP::iterator iter1 = iter->second.TrackSecsMap.find(trackid);	//查找trackid区段是否在接触网轨道区段列表中，如存在，则返回对应的接触网ID
		if (iter1!=iter->second.TrackSecsMap.end())
		{
			Track_Section& sec= iter1->second;
			if (sec.TrackID==trackid&&ex<=sec.EndPos&&ex>=sec.StartPos)
			{
				return iter->second.TouchNetID;
			}
		}
	}
	return "";
}
bool DCSysMG::GetTouchNetPosByRailPosition(int trackid,double railex,string& touchnetid,double&touchnetex)// 通过轨道位置获取接触网的位置（主要是根据轨道编号和偏移量、接触网编号和偏移量进行综合计算）
{
	touchnetex=0;

	TOUCHNETRELAMAP::iterator iter = m_NetTracksRelationMap.begin();
	for (;iter!=m_NetTracksRelationMap.end();iter++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return false;
		}
		TRACKSECMAP::iterator iter1 = iter->second.TrackSecsMap.find(trackid);
		if (iter1!=iter->second.TrackSecsMap.end())
		{
			Track_Section& sec= iter1->second;							//trackid的轨道区段
			if (sec.TrackID==trackid&&railex<=sec.EndPos&&railex>=sec.StartPos)
			{
				//当前接触网对应0~n段轨道区段 xyx注释
				touchnetid= iter->second.TouchNetID;
				touchnetex = sec.EndPos-railex;      //车在当前轨道区段(第i段)上的偏移exi xyx注释
				int index=sec.Index;                 //当前轨道区段i xyx注释
				TRACKSECMAP::iterator iter2 = iter->second.TrackSecsMap.begin();
				for (;iter2!=iter->second.TrackSecsMap.end();iter2++)
				{
					if (iter2->second.Index<index)  //若车所在当前轨道区段i不是第一段(即index!=0) xyx注释
					{
						touchnetex+=(iter2->second.EndPos-iter2->second.StartPos);  //车在接触网上的总偏移ex = 前i-1段轨道区段长度ex[0~(i-1)]之和 + 车在当前轨道区段i上的偏移exi xyx注释
					}
				}
				return true;
			}
		}
	}
	return false;
}
//查找节点LIST的索引（根据接触网编号和偏移量，列车运行方向，上下行线路节点数据进行查找）
size_t DCSysMG::FindNodeListIndex(string touchnetid,double ex,int arrow,vector<LineNodeData>& m_UpRunDataList,vector<LineNodeData>& m_DownRunDataList)
{
	TOUCHNETMAP::iterator itertrian = TouchNetMap.find(touchnetid);
	if (itertrian!=TouchNetMap.end()&&itertrian->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
	{
		CElectricEqpmt_Line_TouchNet*TouchNettrian=itertrian->second;
		if (arrow == TRAIN_DIR_UP)							//列车运行方向为上行
		{
			for (size_t i=0;i<m_UpRunDataList.size();i++)
			{
				TOUCHNETMAP::iterator iterlist = TouchNetMap.find(m_UpRunDataList[i].TouchNetID);
				if (iterlist!=TouchNetMap.end()&&iterlist->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
				{
					CElectricEqpmt_Line_TouchNet*TouchNetlist=iterlist->second;

					if (TouchNettrian->GetIndex()<=TouchNetlist->GetIndex())
					{
						if (TouchNettrian->GetIndex()<TouchNetlist->GetIndex())	//touchnetid节点对应的索引小于上行数据列表对应的索引
						{
							return i;											//则上行数据列表对应的索引号
						}
						if (TouchNettrian->GetIndex()==TouchNetlist->GetIndex())
						{
							if (ex<=m_UpRunDataList[i].excursion)
							{
								return i;
							}
						}
					}
				}
			}
		}
		else if (arrow == TRAIN_DIR_DOWN)							//列车运行方向为下行
		{
			for (size_t i=0;i<m_DownRunDataList.size();i++)
			{
				TOUCHNETMAP::iterator iterlist = TouchNetMap.find(m_DownRunDataList[i].TouchNetID);
				if (iterlist!=TouchNetMap.end()&&iterlist->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
				{
					CElectricEqpmt_Line_TouchNet*TouchNetlist=iterlist->second;
					if (TouchNettrian->GetIndex()<=TouchNetlist->GetIndex())
					{
						if (TouchNettrian->GetIndex()<TouchNetlist->GetIndex())
						{
							return i;
						}
						if (TouchNettrian->GetIndex()==TouchNetlist->GetIndex())
						{
							if (ex<=m_DownRunDataList[i].excursion)
							{
								return i;
							}
						}
					}
				}
			}
		}
	}
	return -1;
}
bool DCSysMG::AddTrainToNodes(DCSysTrain& train,vector<LineNodeData>& m_UpRunDataList,vector<LineNodeData>& m_DownRunDataList)
{	//将列车信息添加到上行数据列表或下行数据列表中
	if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
	{
		return false;
	}
	//下面为对列车相关的数据进行初始化，并指明它的运行状态和方向
	vector<LineNodeData>* PRunDataList;
	if (train.arrow == TRAIN_DIR_UP)
	{
		PRunDataList=&m_UpRunDataList;
	}
	else if (train.arrow==TRAIN_DIR_DOWN)
	{
		PRunDataList=&m_DownRunDataList;
	}
	else
	{
		return false;
	}

	string triantouchid;
	double trianex;
	if (!JudgeShortCutAreaTrian(train))		//判断train是否在断路区域	
	{
		return false;
	}
	if (!GetTouchNetPosByRailPosition(train.LineSectionID,train.excursion,triantouchid,trianex))//通过轨道位置获取train的接触网位置  
	{
		return false;
	}
	size_t pos=FindNodeListIndex(triantouchid,trianex,train.arrow,m_UpRunDataList,m_DownRunDataList); 
	if (pos>0&&pos<PRunDataList->size()-1)
	{
		TRIANONLINE pUpTrain;			//列车与接触网的节点    //列车受电弓节点 xyx注释
		int UpNodeID = CreateNodeID();
		if (UpNodeID<0)
			return false;

		pUpTrain.Init(NodeIndex,UpNodeID,Dc_NodeKind_UpTrain);
		pUpTrain.PowerRate = train.PowerRate;
		NodeIndex++;
		pUpTrain.SetTrianInfo(train.ID,train.LineSectionID,train.excursion,train.arrow);
		//	pUpTrain->SetDcNodeMap(&m_DcYFixNodesMap,&m_CritilSecYNodesMap);

		TRIANONRAILWAY pTrianRailway;			//列车与轨道间的节点      //列车轮对节点 xyx注释
		int UpRailNodeID = CreateNodeID();
		if (UpRailNodeID<0)
			return false;

		pTrianRailway.Init(NodeIndex,UpRailNodeID,Dc_NodeKind_DownTrain);
		pTrianRailway.PowerRate = train.PowerRate;

		NodeIndex++;
		pUpTrain.SetRailwayNode(UpRailNodeID);		//设置列车上行方向与轨道的节点              //将列车轮对节点设置为受电弓节点的关联节点 xyx注释
		pTrianRailway.SetOnlineNode(UpNodeID);		//设置列车上行方向与接触网的节点的节点      //将受电弓节点设置为列车轮对节点的关联节点 xyx注释

		//GetTouchNetDurDistance获取一个周期内接触网的距离
		
		//以下功能为：将当前列车节点（含列车受电弓节点、轮对节点）插入已知的两节点中 xyx注释
		//情形1：处理当前列车节点与前一节点的关系 xyx注释
		double distance = GetTouchNetDurDistance((*PRunDataList)[pos-1].TouchNetID,(*PRunDataList)[pos-1].excursion,triantouchid,trianex,train.arrow);

		//电力节点的生成并根据列车运行方向对其初始化
		DCYSNODEMAP::iterator iter = m_DCNodesMap.find((*PRunDataList)[pos-1].ID);
		if (iter!=m_DCNodesMap.end()&&distance>=0)
		{
			//情形1-1：若已知前一节点为直流正极母线节点 xyx注释
			if (iter->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_RectierToTouchNet)//节点类型：整流器到接触网
			{
				POWERNODE& PowerNode = iter->second;
				if (train.arrow == TRAIN_DIR_UP)
				{ 
					PowerNode.RectierToTouchNetNode.SetUpNextNode(UpNodeID,distance,true);  //上行：将受电弓节点设为直流正极母线节点的下一个节点 xyx注释
				}
				else if (train.arrow==TRAIN_DIR_DOWN)
				{
					PowerNode.RectierToTouchNetNode.SetDownNextNode(UpNodeID,distance,true); //下行：将受电弓节点设为直流正极母线节点的下一个节点 xyx注释
				}

				DCYSNODEMAP::iterator iter2 = m_DCNodesMap.find(PowerNode.RectierToTouchNetNode.GetInnerNodeID());	//查找内节点
				if (iter2!=m_DCNodesMap.end())
				{
					POWERNODE& PowerNode1 = iter2->second;
					int railwayid;
					if (train.arrow == TRAIN_DIR_UP)
					{
						railwayid = PowerNode1.RectierToRailwayNode.GetUpNode();
					}
					else if (train.arrow==TRAIN_DIR_DOWN)
					{
						railwayid = PowerNode1.RectierToRailwayNode.GetDownNode();
					}

					DCYSNODEMAP::iterator iter3 = m_DCNodesMap.find(railwayid);
					if (iter3!=m_DCNodesMap.end())
					{
						POWERNODE& PowerNode2 = iter3->second;
						PowerNode2.RailWayNode.SetNextNode(UpRailNodeID,distance,true);   //将列车轮对节点设为直流负极母线节点的下一个节点 xyx注释
						pTrianRailway.SetPreNode(PowerNode2.NodeID,distance,PowerNode2.RectierToRailwayNode.GetPower());        //将直流负极母线节点设为列车轮对节点的下一个节点 xyx注释
						//							TRACE("RailWayNode id = %d \n",PowerNode2.NodeID);//为测试用例函数，类似于printf()
						// 							TRACE("PreNodeID = %d \n",PowerNode2.RailWayNode.PreNodeID);
						// 							TRACE("NextNodeID = %d \n",PowerNode2.RailWayNode.NextNodeID);
						// 							TRACE("RectierNodeID = %d \n",PowerNode2.RailWayNode.RectierNodeID);
						// 							TRACE("\n");
					}
				}
				pUpTrain.SetPreNode(iter->second.NodeID,distance,PowerNode.RectierToTouchNetNode.GetPower());     //将直流正极母线节点设为列车受电弓节点的前一个节点 xyx注释
				// 					TRACE("RectierToTouchNet id = %d \n",PowerNode.NodeID);
				// 					TRACE("UpPreNodeID = %d \n",PowerNode.RectierToTouchNetNode.UpPreNodeID);
				// 					TRACE("DownPreNodeID = %d \n",PowerNode.RectierToTouchNetNode.DownPreNodeID);
				// 					TRACE("UpNextNodeID = %d \n",PowerNode.RectierToTouchNetNode.UpNextNodeID);
				// 					TRACE("DownNextNodeID = %d \n",PowerNode.RectierToTouchNetNode.DownNextNodeID);
				// 					TRACE("\n");
			}
			//情形1-2：若已知前一节点为受电弓节点 xyx注释
			else if (iter->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_UpTrain)	//节点类型：上行列车
			{	
				POWERNODE& PowerNode = iter->second;
				PowerNode.TrianOnLineNode.SetNextNode(UpNodeID,distance,true);     //将当前受电弓节点设为已知前一受电弓节点的下一节点 xyx注释
				DCYSNODEMAP::iterator iter4 = m_DCNodesMap.find(PowerNode.TrianOnLineNode.GetRailwayNodeID());
				if (iter4!=m_DCNodesMap.end())
				{
					POWERNODE& PowerNode1 = iter4->second;
					PowerNode1.TrianOnRailway.SetNextNode(UpRailNodeID,distance,true); //将当前轮对节点设为已知前一轮对节点的下一节点 xyx注释 
					pTrianRailway.SetPreNode(PowerNode1.NodeID,distance,true);	//TRIANONRAILWAY pTrianRailway;//?列车在轨道   //将已知前一轮对节点设为当前轮对节点的前一节点 xyx注释 
					// 						TRACE("TrianOnRailway id = %d \n",PowerNode1.NodeID);
					// 						TRACE("PreNodeID = %d \n",PowerNode1.TrianOnRailway.PreNodeID);
					// 						TRACE("NextNodeID = %d \n",PowerNode1.TrianOnRailway.NextNodeID);
					// 						TRACE("\n");
				}
				pUpTrain.SetPreNode(iter->second.NodeID,distance,true);      //将已知前一受电弓节点为当前受电弓节点的前一节点 xyx注释
			}
			//情形1-3：若已知前一节点为轨道头节点 xyx注释
			else if (iter->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_HeadTail)
			{
				POWERNODE& PowerNode = iter->second;
				if (PowerNode.HeadTailNode.m_NodeCategory==Dc_NodeKind_UPHead||PowerNode.HeadTailNode.m_NodeCategory==Dc_NodeKind_DownHead)
				{
					PowerNode.HeadTailNode.SetDownNode(UpRailNodeID,trianex,true);  //将当前轮对节点设为已知轨道头节点的下一节点 xyx注释
					pTrianRailway.SetPreNode(PowerNode.NodeID,trianex,true);        //将已知轨道头节点设为当前轮对节点的上一节点 xyx注释
				}
				else
					return false;
			}
			else 
				return false;

		}
		else
			return false;

		//情形2：处理当前列车节点与后一节点间的关系 xyx注释
		distance = GetTouchNetDurDistance(triantouchid,trianex,(*PRunDataList)[pos].TouchNetID,(*PRunDataList)[pos].excursion,train.arrow);
		DCYSNODEMAP::iterator iter1 = m_DCNodesMap.find((*PRunDataList)[pos].ID);
		if (iter1!=m_DCNodesMap.end()&&distance>=0)
		{
			//情形2-1：若已知后一节点为直流正极母线节点 xyx注释
			if (iter1->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_RectierToTouchNet)
			{
				POWERNODE& pRecterToTouchNet = iter1->second;
				if (train.arrow == TRAIN_DIR_UP)
				{
					pRecterToTouchNet.RectierToTouchNetNode.SetUpPreNode(UpNodeID,distance,true);  //上行：将当前受电弓节点设为已知后一直流正极母线节点的前一节点 xyx注释
				}
				else if (train.arrow==TRAIN_DIR_DOWN)
				{
					pRecterToTouchNet.RectierToTouchNetNode.SetDownPreNode(UpNodeID,distance,true); //下行
				}

				DCYSNODEMAP::iterator iter5 = m_DCNodesMap.find(pRecterToTouchNet.RectierToTouchNetNode.GetInnerNodeID());  //查找与当前直流正极母线节点关联的直流负极母线节点 xyx注释
				if (iter5!=m_DCNodesMap.end()) 
				{
					POWERNODE& PowerNode =iter5->second;
					int railwayid;
					if (train.arrow == TRAIN_DIR_UP)
					{
						railwayid = PowerNode.RectierToRailwayNode.GetUpNode();    //获取直流负极母线节点上的上行回流负极节点 xyx注释
					}
					else if (train.arrow==TRAIN_DIR_DOWN)
					{
						railwayid = PowerNode.RectierToRailwayNode.GetDownNode();   //获取直流负极母线节点上的下行回流负极节点 xyx注释
					}
					DCYSNODEMAP::iterator iter6 = m_DCNodesMap.find(railwayid);
					if (iter6!=m_DCNodesMap.end())
					{
						POWERNODE& PowerNode1 = iter6->second;
						PowerNode1.RailWayNode.SetPreNode(UpRailNodeID,distance,true);   //将列车轮对节点设为已知后端直流负极母线节点的前一个节点 xyx注释
						pTrianRailway.SetNextNode(PowerNode1.NodeID,distance,PowerNode.RectierToRailwayNode.GetPower());      //将已知后端直流负极母线节点设为列车轮对节点的后一个节点 xyx注释
						// 							TRACE("RailWayNode id = %d \n",PowerNode1.NodeID);
						// 							TRACE("PreNodeID = %d \n",PowerNode1.RailWayNode.PreNodeID);
						// 							TRACE("NextNodeID = %d \n",PowerNode1.RailWayNode.NextNodeID);
						// 							TRACE("RectierNodeID = %d \n",PowerNode1.RailWayNode.RectierNodeID);
						// 							TRACE("\n");
					}
				}
				pUpTrain.SetNextNode(iter1->second.NodeID,distance,pRecterToTouchNet.RectierToTouchNetNode.GetPower());    //将已知后端直流正极母线节点设为当前受电弓节点的后一节点 xyx注释
				// 					TRACE("RectierToTouchNet id = %d \n",pRecterToTouchNet.NodeID);
				// 					TRACE("UpPreNodeID = %d \n",pRecterToTouchNet.RectierToTouchNetNode.UpPreNodeID);
				// 					TRACE("DownPreNodeID = %d \n",pRecterToTouchNet.RectierToTouchNetNode.DownPreNodeID);
				// 					TRACE("UpNextNodeID = %d \n",pRecterToTouchNet.RectierToTouchNetNode.UpNextNodeID);
				// 					TRACE("DownNextNodeID = %d \n",pRecterToTouchNet.RectierToTouchNetNode.DownNextNodeID);
				// 					TRACE("\n");
			}
			//情形2-2：若已知后一节点为受电弓节点 xyx注释
			else if (iter1->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_UpTrain)
			{
				POWERNODE& PowerNode = iter1->second;
				PowerNode.TrianOnLineNode.SetPreNode(UpNodeID,distance,true);    //将当前受电弓节点设为已知后端受电弓节点的前一节点 xyx注释

				DCYSNODEMAP::iterator iter7 = m_DCNodesMap.find(PowerNode.TrianOnLineNode.GetRailwayNodeID());
				if (iter7!=m_DCNodesMap.end())
				{
					POWERNODE& PowerNode1 = iter7->second;

					PowerNode1.TrianOnRailway.SetPreNode(UpRailNodeID,distance,true); //将当前轮对节点设为已知后端轮对节点的前一节点 xyx注释
					pTrianRailway.SetNextNode(PowerNode1.NodeID,distance,true);       //将已知后端轮对节点设为当前轮对节点的后一节点 xyx注释
					// 						TRACE("TrianOnRailway id = %d \n",PowerNode1.NodeID);
					// 						TRACE("PreNodeID = %d \n",PowerNode1.TrianOnRailway.PreNodeID);
					// 						TRACE("NextNodeID = %d \n",PowerNode1.TrianOnRailway.NextNodeID);
					// 						TRACE("\n");

				}
				pUpTrain.SetNextNode(iter1->second.NodeID,distance,true);        //将已知后端受电弓节点设为当前受电弓节点的后一节点 xyx注释
			}
			//情形2-3：若已知后一节点为轨道尾节点 xyx注释
			else if (iter->second.nodeType==tgPowerNode::NodeType::eDc_NodeKind_HeadTail)
			{
				POWERNODE& PowerNode = iter->second;
				if (PowerNode.HeadTailNode.m_NodeCategory==Dc_NodeKind_UPTail||PowerNode.HeadTailNode.m_NodeCategory==Dc_NodeKind_DownTail)
				{
					PowerNode.HeadTailNode.SetDownNode(UpRailNodeID,trianex,true);   //将当前轮对节点设为已知轨道尾节点的前一节点  xyx注释
					pTrianRailway.SetNextNode(PowerNode.NodeID,trianex,true);        //将已知轨道尾节点设为当前轮对节点的后一节点  xyx注释
				}
				else
					return false;
			}
			else 
				return false;
		}
		else
			return false;

		//将当前受电弓节点添加至接触线路的信息中  xyx注释
		LineNodeData trainnode;
		trainnode.ID = UpNodeID;
		trainnode.excursion = trianex;
		trainnode.Kind = Dc_NodeKind_UpTrain;
		trainnode.TouchNetID = triantouchid;

		//将当前受电弓节点添加至上、下行接触线沿线的节点列表m_UpRunDataList、m_DownRunDataList中 xyx注释
		if (train.arrow == TRAIN_DIR_UP)
		{
			m_UpRunDataList.insert(m_UpRunDataList.begin()+pos,trainnode);   
		}
		else if (train.arrow==TRAIN_DIR_DOWN)
		{
			m_DownRunDataList.insert(m_DownRunDataList.begin()+pos,trainnode);
		}

		//将当前受电弓节点添加至直流节点m_DCNodesMap中 xyx注释
		POWERNODE PowerNode1;
		PowerNode1.setTrianOnLine(&pUpTrain);
		m_DCNodesMap.insert(make_pair(UpNodeID,PowerNode1));

		POWERNODE PowerNode2;
		PowerNode2.setTrianOnRailway(&pTrianRailway);
		m_DCNodesMap.insert(make_pair(UpRailNodeID,PowerNode2));

		return true;
	}
	return false;
}
double DCSysMG::GetTouchLenght(string id)				//获取接触网的长度
{
	double len=0;
	TOUCHNETRELAMAP::iterator iter = m_NetTracksRelationMap.find(id);//根据id号在接触网与轨道的关系表中查询信息
	if (iter!=m_NetTracksRelationMap.end())
	{
		TRACKSECMAP::iterator iter2 = iter->second.TrackSecsMap.begin();
		for (;iter2!=iter->second.TrackSecsMap.end();iter2++)
		{
			len+=(iter2->second.EndPos-iter2->second.StartPos);//长度计算   //接触网对应多段轨道区段，则接触网长度=多段轨道区段长度总和 xyx注释
		}
	}
	return len;
}
bool DCSysMG::CreateFixYNodes()		//创建固定节点   
{	
	m_DCFixNodesMap.clear();
	m_DCNodesMap.clear();

	NodeIDsCount=1000;
	NodeIndex=0;

	if (!CreateHeadNodes())			//创建头节点
	{
		return false;
	}
	if (!CreateTailNodes())			//创建尾节点
	{
		return false;
	}
	
	DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.begin(); 
	while (iter!=m_PowerStationNodeMap.end())
	{
		if (iter->second.GetID()>0)
		{
			if (!CreateRectierToTouchNetNode(iter->second))		//创建整流器到接触网节点
			{
				return false;
			}
			if (!CreateRectierToRailWayNode(iter->second))		//创建整流器到轨道节点
			{
				return false;
			}
			if (!CreateRailWayNode(iter->second))				//创建轨道节点
			{
				return false;
			}
		}
		iter = m_PowerStationNodeMap.find(iter->second.GetNextStationID());//GetNextStationID()获取下一个车站节点的ID号
		//iter++;
		//if (iter ==nullptr)
		//{
		//	return false;
		//}
	}
	PushTailNodes();			//将尾节点添加到固定节点列表中
	return true;
}
int  DCSysMG::GetRelaNodeRectIndex(int RelationNodeID)				//获取关系节点的矩阵索引   //获取关系节点的编号 xyx注释
{

	DCYSNODEMAP::iterator iter = m_DCNodesMap.find(RelationNodeID);
	if (iter!=m_DCNodesMap.end())
	{
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_HeadTail)//?HeadTail?
		{
			return iter->second.HeadTailNode.GetRectIndex();
		}
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RailWay)
		{
			return iter->second.RailWayNode.GetRectIndex();
		}
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToRailWay)//?
		{
			return iter->second.RectierToRailwayNode.GetRectIndex();
		}
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)//、?
		{
			return iter->second.RectierToTouchNetNode.GetRectIndex();
		}
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_UpTrain)
		{
			return iter->second.TrianOnLineNode.GetRectIndex();
		}
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_DownTrain)
		{
			return iter->second.TrianOnRailway.GetRectIndex();
		}
	}
	return -1;
}
void DCSysMG::GetRectiterVPublish(std::vector<POWERVALUE>& PQIList)				//获取整流器电压发布数据信息
{
	DCYSNODEMAP::iterator iter = m_DCNodesMap.begin();
	for (;iter!=m_DCNodesMap.end();iter++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return;
		}
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)	//整流器到接触网
		{
			POWERVALUE TrianNodeV;
			RECTIERTOTOUCHNET& RectierNode = iter->second.RectierToTouchNetNode;
			TrianNodeV.V=m_EquationCalcul.b[RectierNode.m_RectIndex][m_EquationCalcul.lie-1];  //直流母线节点电压
			TrianNodeV.ID=RectierNode.m_NodeID;
			TrianNodeV.StationID=RectierNode.StationID;
			PQIList.push_back(TrianNodeV);								//保存电压
		}
	}
}
void DCSysMG::GetTrianVPublish(std::vector<POWERVALUE>& PQIList)			//获取列车电压发布值
{
	DCYSNODEMAP::iterator iter = m_DCNodesMap.begin();
	for (;iter!=m_DCNodesMap.end();iter++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return;
		}
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_UpTrain)
		{
			POWERVALUE TrianNodeV;
			TRIANONLINE& TrianOnLineNode = iter->second.TrianOnLineNode;
			TrianNodeV.V=m_EquationCalcul.b[TrianOnLineNode.m_RectIndex][m_EquationCalcul.lie-1];   //列车受电弓节点电压
			TrianNodeV.ID=TrianOnLineNode.TrianNO;
			TrianNodeV.StationID=TrianOnLineNode.LineSectionNo;
			PQIList.push_back(TrianNodeV); //保存电压
		}
	}
	map<int,DCSysTrain>::iterator iter1 = m_ShortCutAreaTrians.begin();//短路区域列车的查找
	for (;iter1!=m_ShortCutAreaTrians.end();iter1++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return;
		}
		POWERVALUE TrianNodeV;
		TrianNodeV.V=0;			//在短路区域的列车电压为0
		TrianNodeV.ID=iter1->first;
		PQIList.push_back(TrianNodeV); 
	}
}

void DCSysMG::GetBackVIPublish(std::vector<POWERVALUE>& PQIList)	//获取回流线电压、电流的发布数据
{
	DCYSNODEMAP::iterator iter = m_DCNodesMap.begin();
	for (;iter!=m_DCNodesMap.end();iter++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return;
		}
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
		{
			POWERVALUE BackVI;
			RECTIERTOTOUCHNET& BackNode = iter->second.RectierToTouchNetNode;
			BackVI.V=m_EquationCalcul.b[BackNode.m_RectIndex][m_EquationCalcul.lie-1];   //直流正极母线节点电压
			BackVI.StationID=BackNode.StationID;

			float tmpv;
			float tmplen=BackNode.Len_UpPreNode;
			DCYSNODEMAP::iterator iterUpPre = m_DCNodesMap.find(BackNode.UpPreNodeID);		//上行前一节点的相关计算
			if (iterUpPre!=m_DCNodesMap.end())
			{
				tmpv = m_EquationCalcul.b[iterUpPre->second.GetRectIndex()][m_EquationCalcul.lie-1];//暂存电压的计算方法
				tmplen = BackNode.Len_UpPreNode;
				BackVI.InputI = (BackVI.V-tmpv)/(tmplen*R_Rate_ContactLine);//回流线电流的计算   //上行：前一直流母线节点与当前母线节点间的接触网线路电流 xyx注释
			}	

			DCYSNODEMAP::iterator iterUpNext = m_DCNodesMap.find(BackNode.UpNextNodeID);//上行下一节点的相关计算
			if (iterUpNext!=m_DCNodesMap.end())
			{
				tmpv = m_EquationCalcul.b[iterUpNext->second.GetRectIndex()][m_EquationCalcul.lie-1];
				tmplen = BackNode.Len_UpNextNode;
				BackVI.OutputI = (BackVI.V-tmpv)/(tmplen*R_Rate_ContactLine);            //上行：后一直流母线节点与当前母线节点间的接触网线路电流 xyx注释
			}

			DCYSNODEMAP::iterator iterDownNext = m_DCNodesMap.find(BackNode.DownNextNodeID);//下行下一节点的相关计算
			if (iterDownNext!=m_DCNodesMap.end())
			{
				tmpv = m_EquationCalcul.b[iterDownNext->second.GetRectIndex()][m_EquationCalcul.lie-1];
				tmplen = BackNode.Len_DownNextNode;
				BackVI.P = (BackVI.V-tmpv)/(tmplen*R_Rate_ContactLine);	//下行下一节点电流 //下行：后一直流母线节点与当前母线节点间的接触网线路电流（此处将电流值赋予节点有功变量？？） xyx注释
			}

			DCYSNODEMAP::iterator iterDownPre = m_DCNodesMap.find(BackNode.DownPreNodeID);//下行前一节点的相关计算
			if (iterDownPre!=m_DCNodesMap.end())
			{
				tmpv = m_EquationCalcul.b[iterDownPre->second.GetRectIndex()][m_EquationCalcul.lie-1];
				tmplen = BackNode.Len_DownPreNode;
				BackVI.Q = (BackVI.V-tmpv)/(tmplen*R_Rate_ContactLine);	//下行前一节点电流 //下行：前一直流母线节点与当前母线节点间的接触网线路电流（此处将电流值赋予节点无功变量？？） xyx注释
			}
			PQIList.push_back(BackVI); 
		}
	}
}
bool DCSysMG::JudgeShortCutAreaTrian(DCSysTrain& train)			//判断train是否在短路区域
{
	string curtouchnet=GetTouchNetByPosition(train.LineSectionID,train.excursion);   //获取列车所在的接触网ID xyx注释
	m_ShortCutAreaTrians.erase(train.ID);
	ELEEQPMTMAP:: iterator itEqpmt = ElectricEqpmtMap.find(curtouchnet);
	if (itEqpmt!=ElectricEqpmtMap.end())
	{
		//if (iter->second->GetType()==OCC_EQPMTTYPE_1500vThirdTrack&&iter->second->GetStatus()==Electric_Eqpmt_Status_OFF)  //判断列车是否在无电区
		if (itEqpmt->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet&&itEqpmt->second->GetStatus()==Electric_Eqpmt_Status_OFF)  //判断列车是否在无电区
		{
			m_ShortCutAreaTrians.insert(make_pair(train.ID,train));        //m_ShortCutAreaTrians 无电区列车列表
			return false;
		}
	}
	//TOUCHNETMAP::iterator iter = TouchNetMap.find(curtouchnet);
	//if (iter!=TouchNetMap.end())
	//{
	//	//if (iter->second->GetType()==Electric_EqpmtType_TouchNetLine&&iter->second->GetStatus()==Electric_Eqpmt_Status_OFF)  //判断列车是否在无电区
	//	if (iter->second->GetType()==Electric_EqpmtType_TouchNetLine&&iter->second->m_status==Electric_Eqpmt_Status_OFF)  //判断列车是否在无电区
	//	{
	//		m_ShortCutAreaTrians.insert(make_pair(train.ID,train));        //m_ShortCutAreaTrians 无电区列车列表
	//		return false;
	//	}
	//}
	return true;
}
bool DCSysMG::CreateRectArray()		//生成矩阵数组  //生成节点导纳矩阵[前m_DCNodesMap.size()行，m_DCNodesMap.size()列]+节点注入电流（每行的最后一列） xyx注释
{
	m_EquationCalcul.Clear();
	m_EquationCalcul.SetHangLie(m_DCNodesMap.size(),m_DCNodesMap.size()+1);
	DCYSNODEMAP::iterator iter = m_DCNodesMap.begin();
	for (size_t i=0;iter!=m_DCNodesMap.end() && i < m_nMaxSigleArrowTrainNums;i++,iter++)									////Max_SigleArrowTrain_Nums单方向最大列车运行数量
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return false;
		}
		//情形1：矩阵中头、尾节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii=0 xyx注释
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_HeadTail)													//电力头尾节点类型的判断
		{
			HEADTAIL& HeadTail = iter->second.HeadTailNode;
			DCYSNODEMAP::iterator iterfix = m_DCFixNodesMap.find(iter->second.NodeID);
			HEADTAIL& headold = iterfix->second.HeadTailNode;															//headold原节点
			if (HeadTail.m_RectIndex>=0&&HeadTail.m_RectIndex<m_DCNodesMap.size()&&HeadTail.m_RectIndex < m_nMaxSigleArrowTrainNums)
			{
				m_EquationCalcul.SetParam(HeadTail.m_RectIndex,HeadTail.m_RectIndex,HeadTail.GetSelfYValue());			//对角元素(m_RectIndex,m_RectIndex)  //节点矩阵主对角线元素：当前节点的自导Yii xyx注释
			}
			for (int i =0;i<HeadTail.RelationCount;i++ )
			{
				int relationid = HeadTail.RelaNodes[i].NodeID;
				double HD = HeadTail.GetRelaNodeYValue(relationid);			//当前节点与关联节点间的互导 xyx注释		//获取关系节点导纳值    
				int rectindex = GetRelaNodeRectIndex(relationid);			//关联节点间的编号 xyx注释					//获取关系节点矩阵的索引
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					m_EquationCalcul.SetParam(HeadTail.m_RectIndex,rectindex,HD);	//节点矩阵非对角线元素：当前节点与关联节点间的互导Yij xyx注释   //与对角元素同行的关系节点元素 (m_RectIndex,rectindex)
				}
			}
			m_EquationCalcul.SetParam(HeadTail.m_RectIndex,m_DCNodesMap.size(),0.0); //最后一列：节点注入电流Ii=0 xyx注释                           //m_RectIndex行的最后一个元素设置为0
		}
		//情形2：矩阵中直流正极母线节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii（为+） xyx注释
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)										  //整流器到接触网节点类型的判断
		{
			RECTIERTOTOUCHNET& RectierToTouchNetNode = iter->second.RectierToTouchNetNode;
			
			if (RectierToTouchNetNode.m_RectIndex>=0&&RectierToTouchNetNode.m_RectIndex<m_DCNodesMap.size()&&RectierToTouchNetNode.m_RectIndex< m_nMaxSigleArrowTrainNums)
			{
				if (!RectierToTouchNetNode.GetPower())   //根据节点带电状态设置自导  xyx注释
				{
					m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,RectierToTouchNetNode.m_RectIndex,0.0);
				}
				else
				{
					m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,RectierToTouchNetNode.m_RectIndex,RectierToTouchNetNode.GetSelfYValue());  //主对角线元素：自导Yii xyx注释
				}
			}
			for (int i =0;i<Max_NodeRelationNums;i++ )
			{
				int relationid = RectierToTouchNetNode.RelaNodes[i].NodeID;
				double HD = RectierToTouchNetNode.GetRelaNodeYValue(relationid);
				int rectindex = GetRelaNodeRectIndex(relationid);
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					if (!RectierToTouchNetNode.GetPower())    //根据节点带电状态设置互导  xyx注释
					{ 
						m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,rectindex,0.0);
					}
					else
					{
						m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,rectindex,HD);  //非主对角线元素：互导Yij xyx注释
					}
				}
			}
			double I=0;
			DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.find(RectierToTouchNetNode.StationID);
			if (iter1!=m_PowerStationNodeMap.end())
			{
				Dc_PowerStation&  powerstation = iter1->second;
				I=powerstation.GetInnerI();		//节点注入电流Ii=整流器当前运行区间等效电压/等效阻抗 xyx注释		                //获取工区内的电流
			}
			if (!RectierToTouchNetNode.GetPower())    //根据节点带电状态设置注入电流  xyx注释
			{ 
				m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,m_DCNodesMap.size(),0.0);
			}
			else
			{
				m_EquationCalcul.SetParam(RectierToTouchNetNode.m_RectIndex,m_DCNodesMap.size(),I);	//最后一列：节点注入电流Ii(+) xyx注释	//整流器到接触网是消耗电流，则用正
			}
		}
		//情形3：矩阵中直流负极母线上的回流节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii（为-） xyx注释
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToRailWay)										//整流器到轨道节点类型的判断
		{
			RECTIERTORAILWAY& RectierToRailwayNode = iter->second.RectierToRailwayNode;
			if (RectierToRailwayNode.m_RectIndex>=0&&RectierToRailwayNode.m_RectIndex<m_DCNodesMap.size()&&RectierToRailwayNode.m_RectIndex< m_nMaxSigleArrowTrainNums)
			{
				if (!RectierToRailwayNode.GetPower())
				{
					m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,RectierToRailwayNode.m_RectIndex,0.0);  //主对角线元素：自导Yii xyx注释
				}
				else
				{
					m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,RectierToRailwayNode.m_RectIndex,RectierToRailwayNode.GetSelfYValue());  //主对角线元素：自导Yii xyx注释
				}
			}
			for (int i =0;i<RectierToRailwayNode.RelationCount;i++ )
			{
				int relationid = RectierToRailwayNode.RelaNodes[i].NodeID;
				double HD = RectierToRailwayNode.GetRelaNodeYValue(relationid);
				int rectindex = GetRelaNodeRectIndex(relationid);
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					if (!RectierToRailwayNode.GetPower())
					{
						m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,rectindex,0.0);
					}
					else
					{
						m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,rectindex,HD);  //非主对角线元素：互导Yij xyx注释
					}
				}
			}
			double I=0;
			DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.find(RectierToRailwayNode.StationID);
			if (iter1!=m_PowerStationNodeMap.end())
			{
				Dc_PowerStation&  powerstation = iter1->second;
				I=powerstation.GetInnerI();
			}
			if (!RectierToRailwayNode.GetPower())
			{
				m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,m_DCNodesMap.size(),0.0);
			}
			else
			{
				m_EquationCalcul.SetParam(RectierToRailwayNode.m_RectIndex,m_DCNodesMap.size(),-I);	//最后一列：节点注入电流Ii(-) xyx注释 //整流器到轨道的电流是回流，则用负，该行的最后一个元素存储电流值
			}
		}
		//情形4：矩阵中轨道节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii=0 xyx注释
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RailWay)								//轨道节点类型的判断
		{
			RAILWAY& RailWayNode = iter->second.RailWayNode;
			if (RailWayNode.m_RectIndex>=0&&RailWayNode.m_RectIndex<m_DCNodesMap.size()&&RailWayNode.m_RectIndex< m_nMaxSigleArrowTrainNums)
			{
				m_EquationCalcul.SetParam(RailWayNode.m_RectIndex,RailWayNode.m_RectIndex,RailWayNode.GetSelfYValue()); //主对角线元素：自导Yii xyx注释
			}
			for (int i =0;i<RailWayNode.RelationCount;i++ )
			{
				int relationid = RailWayNode.RelaNodes[i].NodeID;
				double HD = RailWayNode.GetRelaNodeYValue(relationid);
				int rectindex = GetRelaNodeRectIndex(relationid);
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					m_EquationCalcul.SetParam(RailWayNode.m_RectIndex,rectindex,HD);  //非主对角线元素：互导Yij xyx注释
				}
			}
			m_EquationCalcul.SetParam(RailWayNode.m_RectIndex,m_DCNodesMap.size(),0);
		}
		//情形5：矩阵中列车受电弓节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii（-） xyx注释
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_UpTrain)									//列车上行节点类型的判断
		{
			TRIANONLINE& TrianOnLineNode = iter->second.TrianOnLineNode;
			if (TrianOnLineNode.m_RectIndex>=0&&TrianOnLineNode.m_RectIndex<m_DCNodesMap.size()&&TrianOnLineNode.m_RectIndex< m_nMaxSigleArrowTrainNums)
			{
				m_EquationCalcul.SetParam(TrianOnLineNode.m_RectIndex,TrianOnLineNode.m_RectIndex,TrianOnLineNode.GetSelfYValue());   //主对角线元素：自导Yii xyx注释
			}
			for (int i =0;i<TrianOnLineNode.RelationCount;i++ )
			{
				int relationid = TrianOnLineNode.RelaNodes[i].NodeID;
				double HD = TrianOnLineNode.GetRelaNodeYValue(relationid);
				int rectindex = GetRelaNodeRectIndex(relationid);
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					m_EquationCalcul.SetParam(TrianOnLineNode.m_RectIndex,rectindex,HD);    //非主对角线元素：互导Yij xyx注释
				}
			}
			double I=0;
			double V=0;
			DCYSNODEMAP::iterator iter2 = m_DCNodesMap.find(TrianOnLineNode.GetRailwayNodeID());
			if (iter2!=m_DCNodesMap.end())
			{
				V = iter2->second.m_NodeV;   //列车轮对节点电压V2
			} 
			double a = iter->second.m_NodeV;  //列车受电弓节点电压V1
			I = TrianOnLineNode.PowerRate/(iter->second.m_NodeV-V);   //列车受电弓节点电流Ii=列车消耗功率/(受电弓节点电压V1-列车轮对节点电压V2)
			m_EquationCalcul.SetParam(TrianOnLineNode.m_RectIndex,m_DCNodesMap.size(),-I);   //最后一列：节点注入电流Ii(-) xyx注释 
		}
		//情形5：矩阵中列车轮对节点参数设置，含：自导Yii,互导Yij,节点注入电流Ii（+） xyx注释
		else if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_DownTrain)										//列车下行节点的判断
		{
			TRIANONRAILWAY& TrianOnRailway = iter->second.TrianOnRailway;
			if (TrianOnRailway.m_RectIndex>=0&&TrianOnRailway.m_RectIndex<m_DCNodesMap.size()&&TrianOnRailway.m_RectIndex< m_nMaxSigleArrowTrainNums)
			{
				
				m_EquationCalcul.SetParam(TrianOnRailway.m_RectIndex,TrianOnRailway.m_RectIndex,TrianOnRailway.GetSelfYValue());     //主对角线元素：自导Yii xyx注释
			}
			for (int i =0;i<TrianOnRailway.RelationCount;i++ )
			{
				int relationid = TrianOnRailway.RelaNodes[i].NodeID;
				double HD = TrianOnRailway.GetRelaNodeYValue(relationid);
				int rectindex = GetRelaNodeRectIndex(relationid);
				if (rectindex>=0&&rectindex<m_DCNodesMap.size()&&rectindex< m_nMaxSigleArrowTrainNums)
				{
					m_EquationCalcul.SetParam(TrianOnRailway.m_RectIndex,rectindex,HD);    //非主对角线元素：互导Yij xyx注释
				}
			}
			double I=0;
			double V=0;
			DCYSNODEMAP::iterator iter2 = m_DCNodesMap.find(TrianOnRailway.GetOnlineNodeID());
			if (iter2!=m_DCNodesMap.end())
			{
				V = iter2->second.m_NodeV;    //列车受电弓节点电压V1
			}
			I = TrianOnRailway.PowerRate/(V-iter->second.m_NodeV);     //列车受电弓节点电流Ii=列车消耗功率/(受电弓节点电压V1-列车轮对节点电压V2)
			double a = iter->second.m_NodeV;     //列车轮对节点电压V2
			m_EquationCalcul.SetParam(TrianOnRailway.m_RectIndex,m_DCNodesMap.size(),I);  //最后一列：节点注入电流Ii(+) xyx注释 
		}
	}
	return true;
}
bool DCSysMG::HaveRightResult()				//检测计算结果的正确性
{
	return HaveResult;
	//return true;
}
void  DCSysMG::OutPutTrainSMap()						//输出列车数据表
{
	m_CritilSec.lock();
	map<int,DCSysTrain>::iterator iter =TrainSInStationMap.begin();
	for (;iter!=TrainSInStationMap.end();iter++)
	{
		DCSysTrain& trian = iter->second;
		//TRACE(" OutPutTrainSMap: Trianid = %d,lineID = %d,excursion = %f,PowerRate = %f,Speed = %f\n",trian.ID,trian.LineSectionID,trian.excursion,trian.PowerRate,trian.Speed);
	}
	m_CritilSec.unlock();
}

bool DCSysMG::OutPutRectValueToFile()				//将矩阵（a,b矩阵的值）的值输入到文件中
{
	try
	{
		std::ofstream sfile("D:\\testdata.txt", std::ios::app);

		if (!sfile) {
			sfile.open("D:\\testdata.txt", std::ios::out);
			if (!sfile) {
				return false;
			}
		}

		// 写入矩阵A
		sfile << "Rect A Values:" << std::endl;
		for (int i = 0; i < 100; i++) {
			sfile << " " << i << " ";
			for (int j = 0; j < 101; j++) {
				sfile << "    " << std::fixed << std::setprecision(3) << m_EquationCalcul.a[i][j];
			}
			sfile << std::endl;
		}

		// 写入矩阵B
		sfile << "Rect B Values:" << std::endl;
		for (int k = 0; k < 100; k++) {
			sfile << " " << k << " ";
			for (int g = 0; g < 101; g++) {
				sfile << "    " << std::fixed << std::setprecision(3) << m_EquationCalcul.b[k][g];
			}
			sfile << std::endl;
		}

		sfile.close();
	}
	catch (...)
	{
		//AfxMessageBox("Write File Error!");
		return false;
	}
	return true;
}
void DCSysMG::AdjustI(double& i)//调整电流值
{
	if (i<0)
	{
		i=-i;
	}
	if (i>5000)//电流值不能超过5000
	{
		i-=1000;
	}
}
bool DCSysMG::CalculRectArray()									//计算矩阵数组
{
	if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
	{
		return false;
	}
	bool CalScope=true;
	
	DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.begin();
	for (;iter!=m_PowerStationNodeMap.end();iter++)
	{
		iter->second.SetWorkArea(1);						//设置第一个工区    //设置整流器初始运行区间为第一区间
		
		////xyx测试begin 设置宝华站整流机组短路
		//if(iter->second.GetID()==3)
		//{
		//	iter->second.SetFualtWorkArea();
		//}
		////xyx测试end
	}
	int e;
    for (e=0;e<Iterate_Calculate_Times;e++)//Iterate_Calculate_Times 500//计算次数
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return false;
		}
		CreateRectArray();      //创建节点导纳+节点注入电流矩阵 xyx注释
		bool Stop=true;
		m_EquationCalcul.jisuan();//计算矩阵的数据
		if (!m_EquationCalcul.CheckResult())  //计算结果
		{
			return false;
		}
		//		OutPutRectValueToFile();
		if (CalScope)
		{
			DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.begin();
			for (;iter1!=m_PowerStationNodeMap.end();iter1++)
			{
				double V_RectierToTouchnet=0;             //整流器到接触网的电压
				double V_RectierToRailway=0;              //整流器到轨道的电压
				Dc_PowerStation&  powerstation = iter1->second;
				DCYSNODEMAP::iterator iter2= m_DCNodesMap.find(powerstation.GetRectierToTouchNetNodeID());   //直流正极母线节点 xyx注释
				
				if (iter2!=m_DCNodesMap.end())
				{
					int id=iter2->second.NodeID;
					//从矩阵b中找出对应的数据，根据ID号对应点所存的数据进行提取
					V_RectierToTouchnet=m_EquationCalcul.b[iter2->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}

				DCYSNODEMAP::iterator iter3= m_DCNodesMap.find(powerstation.GetRectierToRailwayNodeID());    //直流负极母线节点 xyx注释
				if (iter3!=m_DCNodesMap.end())
				{
					V_RectierToRailway=m_EquationCalcul.b[iter3->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}
				//整流器负荷电流i=(负极母线电压+整流器工区压-正极母线电压)/整流器内阻 xyx注释
				double i=(V_RectierToRailway+powerstation.GetWorkAreaV()-V_RectierToTouchnet)/powerstation.GetInnerR();
				//电流的计算方法为：整流器到轨道的电压+相应的工区电压-整流器到接触网的电压/电站内阻
				if (i<0)
				{
					i=-i;
				}
				//xyx新增begin 根据直流母线带电状态确定是否调整工区
				ELEEQPMTMAP::iterator iterRectierToTouchNet =ElectricEqpmtMap.find(iter1->second.GetRectierToTouchNetUnitID());
				if (iterRectierToTouchNet!=ElectricEqpmtMap.end())
				{
					if (!iterRectierToTouchNet->second->GetPower())
					{
						POWERNODE PowerNode;
						//PowerNode.m_NodeV=0.0;
						iter1->second.SetNoWorkArea(false);

						DCYSNODEMAP::iterator iterRecToTouchNet= m_DCNodesMap.find(iter1->second.GetRectierToTouchNetNodeID());
						if (iterRecToTouchNet!=m_DCNodesMap.end())
						{
							iterRecToTouchNet->second.RectierToTouchNetNode.SetPower(false);
							iterRecToTouchNet->second.RectierToTouchNetNode.SetInnerNode(iter1->second.GetRectierToRailwayNodeID(),iter1->second.GetInnerR(),iterRecToTouchNet->second.RectierToTouchNetNode.GetPower());
						}

						DCYSNODEMAP::iterator iterRecToRailway= m_DCNodesMap.find(iter1->second.GetRectierToRailwayNodeID());
						if (iterRecToRailway!=m_DCNodesMap.end())
						{
							iterRecToRailway->second.RectierToRailwayNode.SetPower(false);
							iterRecToRailway->second.RectierToRailwayNode.SetInnerNode(iter1->second.GetRectierToTouchNetNodeID(),iter1->second.GetInnerR(),iterRecToRailway->second.RectierToRailwayNode.GetPower());
						}
					}
					else
					{
						FindCalScope(powerstation,Stop,i);  //判断整流机组负荷电流是否在器工作区间对应的负荷电流范围内 xyx注释
					}
				}
				//xyx新增end
				//FindCalScope(powerstation,Stop,i);  //判断整流机组负荷电流是否在器工作区间对应的负荷电流范围内 xyx注释
			}
		}
		else
		{
			DCYSNODEMAP::iterator iter4=m_DCNodesMap.begin();
			for (;iter4!=m_DCNodesMap.end();iter4++)
			{
				if (iter4->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_UpTrain)  //列车受电弓节点 xyx注释
				{
					double v=0;
					double v1=0;
					DCYSNODEMAP::iterator iter5 = m_DCNodesMap.find(iter4->second.TrianOnLineNode.GetRailwayNodeID());  //当前受电弓节点对应的轮对节点 xyx注释
					if (iter5!=m_DCNodesMap.end()) 
					{
						v = iter4->second.m_NodeV-iter5->second.m_NodeV;//此处电压的计算方法是？？？  //初始列车电压v=受电弓电压-轮对电压 xyx注释
					}
					//	v1=m_EquationCalcul.b[iter4->second.GetRectIndex()][m_EquationCalcul.lie-1];
					//根据矩阵计算方法获取电压值
					//节点电压法计算所得列车电压v1 xyx注释
					v1=m_EquationCalcul.b[iter4->second.GetRectIndex()][m_EquationCalcul.lie-1]-m_EquationCalcul.b[iter5->second.GetRectIndex()][m_EquationCalcul.lie-1];
					
					//判断计算出的各个列车节点电压大小是否已满足给定的收敛精度：|v-v1|<收敛精度Voltage_Calculate_Offsize  xyx注释
					//若不满足精度要求，则将计算得到的电压值v1赋给当前节点 xyx注释
					double vi=v-v1;
					if (v-v1>Voltage_Calculate_Offsize||v-v1<-Voltage_Calculate_Offsize)//电压计算误差 
					{ 
						Stop=false;   //继续迭代 xyx注释
						CalScope=true;  //进入下一次迭代计算，将整理机组工区设置为第一区间重新迭代计算 xyx注释
					} 
					iter4->second.m_NodeV=m_EquationCalcul.b[iter4->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}
				if (iter4->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_DownTrain)
				{
					iter4->second.m_NodeV=m_EquationCalcul.b[iter4->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}
			}
			if (CalScope)
			{
				DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.begin();
				for (;iter!=m_PowerStationNodeMap.end();iter++)
				{
					iter->second.SetWorkArea(1);
				}
			}
		}
		if (Stop)  //若列车节点电压满足精度要求 xyx注释
		{
			if (CalScope)  
			{
				CalScope=false;  //则不需要进行整流机组的工区调整 xyx注释
			}
			else
				break;
		}
	}
	
	//以下为计算结果收敛后，根据潮流计算结果进一步计算得到其他电量值 xyx注释
	if (e<=Iterate_Calculate_Times)//#define   Iterate_Calculate_Times 500//计算次数
	{
		if (p_PQValueArr!=nullptr)
		{
			DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.begin();
			for (;iter1!=m_PowerStationNodeMap.end();iter1++)
			{
				Dc_PowerStation&  powerstation = iter1->second;
				//double V_RectierToTouchnet=0;
				//double V_RectierToRailway=0;
				double V_RectierToTouchnet=0;
				double V_RectierToRailway=0;
				//(1)直流正极母线节点电压 xyx注释
				DCYSNODEMAP::iterator iter2= m_DCNodesMap.find(powerstation.GetRectierToTouchNetNodeID());
				if (iter2!=m_DCNodesMap.end())
				{
					V_RectierToTouchnet=m_EquationCalcul.b[iter2->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}
				//（2）直流负极母线节点电压 xyx注释
				DCYSNODEMAP::iterator iter3= m_DCNodesMap.find(powerstation.GetRectierToRailwayNodeID());
				if (iter3!=m_DCNodesMap.end())
				{
					V_RectierToRailway=m_EquationCalcul.b[iter3->second.GetRectIndex()][m_EquationCalcul.lie-1];
				}
				//（3）整流机组电流 xyx注释
				double i=(V_RectierToRailway+powerstation.GetWorkAreaV()-V_RectierToTouchnet)/powerstation.GetInnerR();
				AdjustI(i);//调整电流值
				for (int k=0;k < m_nAllPowerStationNums;k++)
				{
					if (p_PQValueArr[k].StationID==powerstation.GetID())
					{
						p_PQValueArr[k].P_QY = powerstation.GetWorkAreaV()*i;//整流机组的有功功率 xyx注释
						p_PQValueArr[k].Q_QY = p_PQValueArr[k].P_QY/0.97*0.2431;//无功功率=有功功率*tanφ=P*[sqr(1-cosφ*cosφ)]/cosφ,其中cosφ为牵混所功率因数(=0.97) xyx注释
						double a=p_PQValueArr[k].P_QY;
						double b=p_PQValueArr[k].Q_QY;
					}
				}
					
				//xyx新增 begin 以下为：将计算结果赋给相应的图元
				//（1）直流正极母线图元电压
				ELEEQPMTMAP::iterator iterRectierToTouchNetUnit = ElectricEqpmtMap.find(iter1->second.GetRectierToTouchNetUnitID());
				if (iterRectierToTouchNetUnit!=ElectricEqpmtMap.end())
				{
					if(iterRectierToTouchNetUnit->second->GetPower())
					{
						iterRectierToTouchNetUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
					}
					else
					{
						iterRectierToTouchNetUnit->second->m_EqpmtPowerValue.U = 0.0;
					}
					iterRectierToTouchNetUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_DCBus;   //3代表母线不区分I、II段
				}
				//(2)将直流正极母线节点电压、整流机组电流分流值计算结果->赋给相应的直流馈线断路器
				//(2-1)上行前一馈线断路器
				double Breaker_I=V_RectierToTouchnet/powerstation.GetInnerR()/100;
				ELEEQPMTMAP::iterator iterFeedUpPreBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetFeedUpPreBreakerID());
				if (iterFeedUpPreBreakerUnit!=ElectricEqpmtMap.end())
				{
					if(iterFeedUpPreBreakerUnit->second->GetPower())
					{
						iterFeedUpPreBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						iterFeedUpPreBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/4;
					}
					else
					{
						iterFeedUpPreBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						iterFeedUpPreBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					iterFeedUpPreBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//(2-2)上行后一馈线断路器
				ELEEQPMTMAP::iterator iterFeedUpNextBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetFeedUpNextBreakerID());
				if (iterFeedUpNextBreakerUnit!=ElectricEqpmtMap.end())
				{
					if(iterFeedUpNextBreakerUnit->second->GetPower())
					{
						iterFeedUpNextBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						iterFeedUpNextBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/4;
					}
					else
					{
						iterFeedUpNextBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						iterFeedUpNextBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					iterFeedUpNextBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//(2-3)下行前一馈线断路器
				ELEEQPMTMAP::iterator iterFeedDownPreBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetFeedDownPreBreakerID());
				if (iterFeedDownPreBreakerUnit!=ElectricEqpmtMap.end())
				{
					if(iterFeedDownPreBreakerUnit->second->GetPower())
					{
						iterFeedDownPreBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						iterFeedDownPreBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/4;
					}
					else
					{
						iterFeedDownPreBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						iterFeedDownPreBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					iterFeedDownPreBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//(2-4)下行后一馈线断路器
				ELEEQPMTMAP::iterator iterFeedDownNextBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetFeedDownNextBreakerID());
				if (iterFeedDownNextBreakerUnit!=ElectricEqpmtMap.end())
				{
					if(iterFeedDownNextBreakerUnit->second->GetPower())
					{
						iterFeedDownNextBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						iterFeedDownNextBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/4;
					}
					else
					{
						iterFeedDownNextBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						iterFeedDownNextBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					iterFeedDownNextBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//（3）将直流正极母线节点电压计算结果赋给相应的直流进线开关图元
				//（3-1）直流进线开关I
				ELEEQPMTMAP::iterator itertFirstDCInputBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetFirstDCInputBreakerUnitID());
				if (itertFirstDCInputBreakerUnit!=ElectricEqpmtMap.end())
				{
					if (itertFirstDCInputBreakerUnit->second->GetPower())
					{
						itertFirstDCInputBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						itertFirstDCInputBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/2;
					}
					else
					{
						itertFirstDCInputBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						itertFirstDCInputBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					itertFirstDCInputBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//（3-2）直流进线开关II
				ELEEQPMTMAP::iterator itertSecondDCInputBreakerUnit = ElectricEqpmtMap.find(iter1->second.GetSecondDCInputBreakerUnitID());
				if (itertSecondDCInputBreakerUnit!=ElectricEqpmtMap.end())
				{
					if (itertSecondDCInputBreakerUnit->second->GetPower())
					{
						itertSecondDCInputBreakerUnit->second->m_EqpmtPowerValue.U = V_RectierToTouchnet;
						itertSecondDCInputBreakerUnit->second->m_EqpmtPowerValue.I = Breaker_I/2;
					}
					else
					{
						itertSecondDCInputBreakerUnit->second->m_EqpmtPowerValue.U = 0.0;
						itertSecondDCInputBreakerUnit->second->m_EqpmtPowerValue.I = 0.0;
					}
					itertSecondDCInputBreakerUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_Eqpmt;
				}
				//（4）将直流负极母线节点电压计算结果赋给相应的母线图元
				ELEEQPMTMAP::iterator itertRectierToRailwayUnit = ElectricEqpmtMap.find(iter1->second.GetRectierToRailwayUnitID());
				if (itertRectierToRailwayUnit!=ElectricEqpmtMap.end())
				{
					itertRectierToRailwayUnit->second->m_EqpmtPowerValue.U = V_RectierToRailway;
					itertRectierToRailwayUnit->second->m_EqpmtPowerValue.Position = ISCS_DD_EqpmtPosition_DCBus;
				}
              //xyx新增 end
			}
		}
		HaveResult =true;
	}			
	return true;
}

//以下功能为：根据计算出的整流器负荷电流值判断是否需要调整整流器运行区间 xyx注释
void DCSysMG::FindCalScope(Dc_PowerStation& node,bool& stop,double i)//查询计算范围  
{//在指定的工区内设定相应的轨道与接触网区段，InnerR为内阻即工区电阻，
	double ivalue = node.GetPWorkAreaI();
	//情形1：若某整流器计算出的负荷电流i大于当前工作区间对应的负荷电流范围，则调整该整流机组的工作区间为后一区间 xyx注释
	if (i>node.GetWorkAreaI()&&node.GetWorkArea()<6)//只能计算五个工区的值（出自王～大论文P22）
	{
		stop=false;
		
		node.SetWorkArea(node.GetWorkArea()+1);
		int n1 = node.GetRectierToTouchNetNodeID();
		DCYSNODEMAP::iterator iter2= m_DCNodesMap.find(node.GetRectierToTouchNetNodeID());
		if (iter2!=m_DCNodesMap.end())
		{
			iter2->second.RectierToTouchNetNode.SetInnerNode(node.GetRectierToRailwayNodeID(),node.GetInnerR(),true);
		}
		
		int n2 = node.GetRectierToRailwayNodeID();
		DCYSNODEMAP::iterator iter3= m_DCNodesMap.find(node.GetRectierToRailwayNodeID());
		if (iter3!=m_DCNodesMap.end())
		{
			iter3->second.RectierToRailwayNode.SetInnerNode(node.GetRectierToTouchNetNodeID(),node.GetInnerR(),true);
		}	
	}
	//情形2：若某整流器计算出的负荷电流i小于当前工作区间对应的负荷电流范围，则调整该整流机组的工作区间为前一区间 xyx注释
	else if (i<=node.GetPWorkAreaI())
	{
		stop=false;
		node.SetWorkArea(node.GetWorkArea()-1);
		int n3 = node.GetRectierToTouchNetNodeID();
		DCYSNODEMAP::iterator iter2= m_DCNodesMap.find(node.GetRectierToTouchNetNodeID());
		if (iter2!=m_DCNodesMap.end())
		{
			iter2->second.RectierToTouchNetNode.SetInnerNode(node.GetRectierToRailwayNodeID(),node.GetInnerR(),true);
		}

		DCYSNODEMAP::iterator iter3= m_DCNodesMap.find(node.GetRectierToRailwayNodeID());
		int n4 = node.GetRectierToTouchNetNodeID();
		if (iter3!=m_DCNodesMap.end())
		{
			iter3->second.RectierToRailwayNode.SetInnerNode(node.GetRectierToTouchNetNodeID(),node.GetInnerR(),true);
		}
	}
}
bool DCSysMG::AdjustFixNodeRect(DCYSNODEMAP& NodeMap)			//调整固定节点矩阵的信息
{
	m_CritilSecSpanNet.lock();//?m_CritilSecSpanNet
	for (size_t i=0;i<m_TouchNetSpanNetInfo.size();i++)
	{
		AdjustSpanNetNode(m_TouchNetSpanNetInfo[i]);//根据跨网与接触网的关系设置跨网的节点信息
	}
	m_CritilSecSpanNet.unlock();

	//AdjustShortCutNode();//调整短路节点

	return true;
}
bool DCSysMG::AdjustSpanNetNode(TouchNet_SpanNetApplyPower_Info& AdjustNode)//根据接触网与跨网的供电信息调整跨网节点//TouchNet_SpanNetApplyPower_Info?
{
	//更新不同列车运行方向的跨网信息，将前段与下段的长度作为跨网的长度，下一段的ID号作为跨网的ID号，前段的ID号不用，设为-1
	DCYSNODEMAP::iterator iter = m_DCNodesMap.find(AdjustNode.nodeid);
	if (iter!=m_DCNodesMap.end())
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return false;
		}
		if (iter->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
		{
			if (AdjustNode.arrow==TRAIN_DIR_UP)//上行方向
			{
				double len = iter->second.RectierToTouchNetNode.GetUpPreNodeLen();//GetUpPreNodeLen()?
				len+=iter->second.RectierToTouchNetNode.GetUpNextNodeLen();//跨网长度的计算：整流器到接触网的前后节点间的距离

				DCYSNODEMAP::iterator iterpre = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetUpPreNodeID());
				if (iterpre!=m_DCNodesMap.end())
				{
					if (iterpre->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						//将前一站的直流母线节点的下一个节点设置为当前站直流母线节点的下一个母线节点（后一站的直流母线节点），即：去除(跳过)当前站直流母线节点 xyx注释
						iterpre->second.RectierToTouchNetNode.SetUpNextNode(iter->second.RectierToTouchNetNode.GetUpNextNodeID(),len,true);
						//将当前站的前一直流母线节点参数去除 xyx注释
						iter->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false);//SetUpPreNode(-1,0)
					}
				}
				DCYSNODEMAP::iterator iternext = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetUpNextNodeID());
				if (iternext!=m_DCNodesMap.end())
				{
					if (iternext->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						//将后一站的直流母线节点的上一个节点设置为当前站直流母线节点的上一个母线节点（前一站的直流母线节点），即：去除(跳过)当前站直流母线节点 xyx注释
						iternext->second.RectierToTouchNetNode.SetUpPreNode(iter->second.RectierToTouchNetNode.GetUpPreNodeID(),len,true);
						//将当前站的后一直流母线节点参数去除 xyx注释
						iter->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false);
					}
				}
				for (size_t i=0;i<m_UpRunFixDataList.size();i++)
				{
					if (m_UpRunFixDataList[i].ID==AdjustNode.nodeid)
					{
						m_UpRunFixDataList.erase(m_UpRunFixDataList.begin()+i);  //将当前站上行直流母线节点从上行固定节点中删除
					}
				}
			}
			else if (AdjustNode.arrow==TRAIN_DIR_DOWN)//下行方向：与上行节点同理
			{
				double len = iter->second.RectierToTouchNetNode.GetDownPreNodeLen();
				len+=iter->second.RectierToTouchNetNode.GetDownNextNodeLen();

				DCYSNODEMAP::iterator iterpre = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetDownPreNodeID());
				if (iterpre!=m_DCNodesMap.end())
				{
					if (iterpre->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						iterpre->second.RectierToTouchNetNode.SetDownNextNode(iter->second.RectierToTouchNetNode.GetDownNextNodeID(),len,true);
						iter->second.RectierToTouchNetNode.SetDownPreNode(-1,0,false);
					}
				}
				DCYSNODEMAP::iterator iternext = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetDownNextNodeID());
				if (iternext!=m_DCNodesMap.end())
				{
					if (iternext->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						iternext->second.RectierToTouchNetNode.SetDownPreNode(iter->second.RectierToTouchNetNode.GetDownPreNodeID(),len,true);
						iter->second.RectierToTouchNetNode.SetDownNextNode(-1,0,false);
					}
				}
				for (size_t i=0;i<m_DownFixRunDataList.size();i++)
				{
					if (m_DownFixRunDataList[i].ID==AdjustNode.nodeid)
					{
						m_DownFixRunDataList.erase(m_DownFixRunDataList.begin()+i);
					}
				}		
			}
			else //根据直流进线开关的带电状态确认是否进行直流母线越区供电，若两个直流进线开关均为无电状态，则说明整流机组不工作，上下行均进行越区供电   xyx注释
			{
				//上行
				double lenup = iter->second.RectierToTouchNetNode.GetUpPreNodeLen();//GetUpPreNodeLen()?
				lenup+=iter->second.RectierToTouchNetNode.GetUpNextNodeLen();//跨网长度的计算：整流器到接触网的前后节点间的距离

				DCYSNODEMAP::iterator iterpre1 = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetUpPreNodeID());
				if (iterpre1!=m_DCNodesMap.end())
				{
					if (iterpre1->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						//将前一站的直流母线节点的下一个节点设置为当前站直流母线节点的下一个母线节点（后一站的直流母线节点），即：去除(跳过)当前站直流母线节点 xyx注释
						iterpre1->second.RectierToTouchNetNode.SetUpNextNode(iter->second.RectierToTouchNetNode.GetUpNextNodeID(),lenup,true);
						//将当前站的前一直流母线节点参数去除 xyx注释
						iter->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false);//SetUpPreNode(-1,0)
					}
				}
				DCYSNODEMAP::iterator iternext1 = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetUpNextNodeID());
				if (iternext1!=m_DCNodesMap.end())
				{
					if (iternext1->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						//将后一站的直流母线节点的上一个节点设置为当前站直流母线节点的上一个母线节点（前一站的直流母线节点），即：去除(跳过)当前站直流母线节点 xyx注释
						iternext1->second.RectierToTouchNetNode.SetUpPreNode(iter->second.RectierToTouchNetNode.GetUpPreNodeID(),lenup,true);
						//将当前站的后一直流母线节点参数去除 xyx注释
						iter->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false);
					}
				}
				for (size_t i=0;i<m_UpRunFixDataList.size();i++)
				{
					if (m_UpRunFixDataList[i].ID==AdjustNode.nodeid)
					{
						m_UpRunFixDataList.erase(m_UpRunFixDataList.begin()+i);  //将当前站上行直流母线节点从上行固定节点中删除
					}
				}		
				//下行
				double lendown = iter->second.RectierToTouchNetNode.GetDownPreNodeLen();
				lendown+=iter->second.RectierToTouchNetNode.GetDownNextNodeLen();

				DCYSNODEMAP::iterator iterpre2 = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetDownPreNodeID());
				if (iterpre2!=m_DCNodesMap.end())
				{
					if (iterpre2->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						iterpre2->second.RectierToTouchNetNode.SetDownNextNode(iter->second.RectierToTouchNetNode.GetDownNextNodeID(),lendown,true);
						iter->second.RectierToTouchNetNode.SetDownPreNode(-1,0,false);
					}
				}
				DCYSNODEMAP::iterator iternext2 = m_DCNodesMap.find(iter->second.RectierToTouchNetNode.GetDownNextNodeID());
				if (iternext2!=m_DCNodesMap.end())
				{
					if (iternext2->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
					{
						iternext2->second.RectierToTouchNetNode.SetDownPreNode(iter->second.RectierToTouchNetNode.GetDownPreNodeID(),lendown,true);
						iter->second.RectierToTouchNetNode.SetDownNextNode(-1,0,false);
					}
				}
				for (size_t i=0;i<m_DownFixRunDataList.size();i++)
				{
					if (m_DownFixRunDataList[i].ID==AdjustNode.nodeid)
					{
						m_DownFixRunDataList.erase(m_DownFixRunDataList.begin()+i);
					}
				}
			}
		}
	}
	return true;
}
bool DCSysMG::AdjustShortCutNode()			//是否调整短路节点
{
	//if ( !m_bInit)
	//{
	//	return false;
	//}
    
	//xyx新增 begin
	TOUCHNETMAP::iterator iterTouchNet = TouchNetMap.begin();
	//if (iterTouchNet!=TouchNetMap.end())
	for(;iterTouchNet!=TouchNetMap.end();iterTouchNet++)
	{
		if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)
		{
			return false;
		}
		CElectricEqpmt_Line_TouchNet*TouchNet=iterTouchNet->second;

		DCSTATIONMAP::iterator iterStartStation = m_PowerStationNodeMap.find(TouchNet->GetStartStation());//当前接触网连接的始端站
		DCSTATIONMAP::iterator iterEndStation = m_PowerStationNodeMap.find(TouchNet->GetEndStation());//当前接触网连接的末端站
		if (iterStartStation==m_PowerStationNodeMap.end()||iterEndStation==m_PowerStationNodeMap.end())
		{
			break;
		}
		DCYSNODEMAP::iterator iterStartNode = m_DCFixNodesMap.find(iterStartStation->second.GetRectierToTouchNetNodeID());//始端站的直流正极母线节点
		DCYSNODEMAP::iterator iterEndNode = m_DCFixNodesMap.find(iterEndStation->second.GetRectierToTouchNetNodeID());    //末端站的直流正极母线节点
		
		bool TouchNetPower = true;    //获取当前接触网的带电状态
		ELEEQPMTMAP:: iterator iterTouchNetUnitID = ElectricEqpmtMap.find(iterTouchNet->first);
		if (iterTouchNetUnitID!=ElectricEqpmtMap.end())
		{
			TouchNetPower = iterTouchNetUnitID->second->GetPower();
		}
		
		//上行直流正极母线节点处理
		if (iterTouchNet->second->GetRunDirection()==TRAIN_DIR_UP)
		{
			//（1）当前上行接触网连接的始端断路器开关状态
			bool UpStartBreakerStatus = true; 
			if (iterStartStation!=m_PowerStationNodeMap.end())
			{
				ELEEQPMTMAP:: iterator iterUpStartBreaker = ElectricEqpmtMap.find(iterStartStation->second.GetFeedUpNextBreakerID());  //当前上行接触网连接的始端断路器为始端站的上行后一直流馈线断路器
				if (iterUpStartBreaker!=ElectricEqpmtMap.end())
				{ 
					if (!iterUpStartBreaker->second->GetPower())
					{
						UpStartBreakerStatus = false;
					}
				}
			}
			//（2）当前上行接触网连接的尾端断路器开关状态
			bool UpEndBreakerStatus = true;
			if (iterEndStation!=m_PowerStationNodeMap.end())
			{
				ELEEQPMTMAP:: iterator iterUpEndBreaker = ElectricEqpmtMap.find(iterEndStation->second.GetFeedUpPreBreakerID());  //当前上行接触网连接的末端断路器为末端站的上行前一直流馈线断路器
				if (iterUpEndBreaker!=ElectricEqpmtMap.end())
				{ 
					if (!iterUpEndBreaker->second->GetPower())
					{
						UpEndBreakerStatus = false;
					}
				}
			}
			//（3）直流正极母线节点前后关系调整
			if (iterTouchNet->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
			{
				if (TouchNetPower)  //接触网有电
				{
					if ( UpStartBreakerStatus==false && UpEndBreakerStatus==true )  //始端断路器不带电，末端断路器带电，接触网有电
					{
						if (iterStartNode!=m_DCFixNodesMap.end()&& iterStartNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterStartNode->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false);   //将其下一节点参数设为0
						}
					}
					else if (UpStartBreakerStatus==true && UpEndBreakerStatus==false )  //始端断路器带电，末端断路器不带电，接触网有电
					{
						if (iterEndNode!=m_DCFixNodesMap.end()&& iterEndNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterEndNode->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false); 
						}
					}
				}
				else if (!TouchNetPower)   //接触网无电，且两端断路器均无电
				{
					if ( UpStartBreakerStatus==false && UpEndBreakerStatus==false )
					{
						if (iterStartNode!=m_DCFixNodesMap.end()&& iterStartNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet
							&&iterEndNode!=m_DCFixNodesMap.end()&& iterEndNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterStartNode->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false);
							iterEndNode->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false);
						}
					}
				}
			}
			//(4)将始端站的直流母线节点设为头节点，末端站的直流母线节点设为尾节点
			//if (UpStartBreakerStatus==false || UpEndBreakerStatus==false)      //若当前接触网的始端断路器和末端断路器有任一为无电状态，则作下列处理
			//{
			//	LineNodeData TailNode;                                               //将始端站的直流母线设为尾节点
			//	TailNode.ID = iterStartStation->second.GetRectierToTouchNetNodeID();
			//	TailNode.Kind = Dc_NodeKind_UPTail;
			//	TailNode.TouchNetID = iterTouchNet->first;
			//	TailNode.excursion = 0;
			//	m_UpRunFixDataList.push_back(TailNode);

			//	LineNodeData HeadNode;                                               //将尾端站的直流母线设为头节点
			//	HeadNode.ID = iterEndStation->second.GetRectierToTouchNetNodeID();
			//	HeadNode.Kind = Dc_NodeKind_UPHead;
			//	HeadNode.TouchNetID = iterTouchNet->first;
			//	HeadNode.excursion = 0;
			//	m_UpRunFixDataList.push_back(HeadNode);
			//}
		}
		//下行直流正极母线节点处理:与上行同理
		else if (iterTouchNet->second->GetRunDirection()==TRAIN_DIR_DOWN)
		{
			//（1）当前下行接触网连接的始端断路器开关状态
			bool DownStartBreakerStatus = true; 
			if (iterStartStation!=m_PowerStationNodeMap.end())
			{
				ELEEQPMTMAP:: iterator iterDownStartBreaker = ElectricEqpmtMap.find(iterStartStation->second.GetFeedDownNextBreakerID());  //当前下行接触网连接的始端断路器为始端站的下行后一直流馈线断路器
				if (iterDownStartBreaker!=ElectricEqpmtMap.end())
				{ 
					if (!iterDownStartBreaker->second->GetPower())
					{
						DownStartBreakerStatus = false;
					}
				}
			}
			//（2）当前下行接触网连接的尾端断路器开关状态
			bool DownEndBreakerStatus = true;
			if (iterEndStation!=m_PowerStationNodeMap.end())
			{
				ELEEQPMTMAP:: iterator iterDownEndBreaker = ElectricEqpmtMap.find(iterEndStation->second.GetFeedDownPreBreakerID());  //当前下行接触网连接的末端断路器为末端站的下行前一直流馈线断路器
				if (iterDownEndBreaker!=ElectricEqpmtMap.end())
				{ 
					if (!iterDownEndBreaker->second->GetPower())
					{
						DownEndBreakerStatus = false;
					}
				}
			}
			//（3）直流正极母线节点前后关系调整
			if (iterTouchNet->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet)
			{
				if (TouchNetPower)  //接触网有电
				{
					if ( DownStartBreakerStatus==false && DownEndBreakerStatus==true )  //始端断路器不带电，末端断路器带电，接触网有电
					{
						if (iterStartNode!=m_DCFixNodesMap.end()&& iterStartNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterStartNode->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false); 
						}
					}
					else if (DownStartBreakerStatus==true && DownEndBreakerStatus==false )  //始端断路器带电，末端断路器不带电，接触网有电
					{
						if (iterEndNode!=m_DCFixNodesMap.end()&& iterEndNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterEndNode->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false); 
						}
					}
				}
				else if (!TouchNetPower)   //接触网无电，且两端断路器均无电
				{
					if ( DownStartBreakerStatus==false && DownEndBreakerStatus==false )
					{
						if (iterStartNode!=m_DCFixNodesMap.end()&& iterStartNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet
							&&iterEndNode!=m_DCFixNodesMap.end()&& iterEndNode->second.nodeType==POWERNODE::NodeType::eDc_NodeKind_RectierToTouchNet)
						{
							iterStartNode->second.RectierToTouchNetNode.SetUpNextNode(-1,0,false);
							iterEndNode->second.RectierToTouchNetNode.SetUpPreNode(-1,0,false);
						}
					}
				}
			}
			//(4)将始端站的直流母线节点设为头节点，末端站的直流母线节点设为尾节点
			//if (DownStartBreakerStatus==false || DownEndBreakerStatus==false)   //若当前接触网的始端断路器和末端断路器有任一为无电状态，则作下列处理
			//{
			//	LineNodeData TailNode;                                               //并将始端站的直流母线设为尾节点
			//	TailNode.ID = iterStartStation->second.GetRectierToTouchNetNodeID();
			//	TailNode.Kind = Dc_NodeKind_DownTail;
			//	TailNode.TouchNetID = iterTouchNet->first;
			//	TailNode.excursion = 0;
			//	m_DownFixRunDataList.push_back(TailNode);

			//	LineNodeData HeadNode;                                               //并将尾端站的直流母线设为头节点
			//	HeadNode.ID = iterEndStation->second.GetRectierToTouchNetNodeID();
			//	HeadNode.Kind = Dc_NodeKind_DownHead;
			//	HeadNode.TouchNetID = iterTouchNet->first;
			//	HeadNode.excursion = 0;
			//	m_DownFixRunDataList.push_back(HeadNode);
			//}
		}
	}
	return true;
	//xyx新增 end

	//xyx屏蔽 begin
	//TOUCHNETMAP::iterator iter = TouchNetMap.begin();
	//if (iter!=TouchNetMap.end())
	//{
	//	//iter++;
	//	if(m_RunStatus!= DISPATCH_RUN_STATUS_RUNNING)
	//	{
	//		return false;
	//	}
	//	if (iter->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet&&iter->second->GetStatus()==Electric_Eqpmt_Status_OFF)
	//	{//接触网的相关信息
	//		CElectricEqpmt_Line_TouchNet*TouchNet=iter->second;

	//		DCSTATIONMAP::iterator iter1 = m_PowerStationNodeMap.find(TouchNet->GetStartStation());//当前接触网连接的始端站
	//		if (iter1!=m_PowerStationNodeMap.end())
	//		{
	//			DCYSNODEMAP::iterator iterstart = m_DCNodesMap.find(iter1->second.GetRectierToTouchNetNodeID());//始端站的直流正极母线节点
	//			if (iterstart!=m_DCNodesMap.end())
	//			{
	//				if (iterstart->second.nodeType==POWERNODE::eDc_NodeKind_RectierToTouchNet)
	//				{
	//					if (iter->second->GetRunDirection()==TRAIN_DIR_UP)
	//					{
	//						iterstart->second.RectierToTouchNetNode.SetUpNextNode(-1,0);  //将始端站上行直流母线的后一节点设为短路 xyx注释
	//						//SetUpNextNode(int id,double len),len=0得到的电阻就为0，因此就设置了第一个电站的下一个区段短路
	//					}
	//					else if (iter->second->GetRunDirection()==TRAIN_DIR_DOWN)
	//					{
	//						iterstart->second.RectierToTouchNetNode.SetDownNextNode(-1,0); //将始端站下行直流母线的后一节点设为短路 xyx注释
	//					}
	//				}
	//			}
	//		}

	//		DCSTATIONMAP::iterator iter2 = m_PowerStationNodeMap.find(TouchNet->GetEndStation());//当前接触网连接的末端站
	//		if (iter2!=m_PowerStationNodeMap.end())
	//		{
	//			DCYSNODEMAP::iterator iterend = m_DCNodesMap.find(iter2->second.GetRectierToTouchNetNodeID());//末端站的直流正极母线节点
	//			if (iterend!=m_DCNodesMap.end())
	//			{
	//				if (iterend->second.nodeType==POWERNODE::eDc_NodeKind_RectierToTouchNet)
	//				{
	//					if (iter->second->GetRunDirection()==TRAIN_DIR_UP)
	//					{
	//						iterend->second.RectierToTouchNetNode.SetUpPreNode(-1,0);   //将末端站上行直流母线的前一节点设为短路 xyx注释
	//					}
	//					else if (iter->second->GetRunDirection()==TRAIN_DIR_DOWN)
	//					{
	//						iterend->second.RectierToTouchNetNode.SetDownPreNode(-1,0); //将末端站下行直流母线的前一节点设为短路 xyx注释
	//					}
	//				}
	//			}
	//		}
	//	}
	//}
	//return true;
	//xyx屏蔽 end
}

void DCSysMG::CalculValue()			//计算相关电力值
{
	if(m_RunStatus== DISPATCH_RUN_STATUS_RUNNING|| m_RunStatus==DISPATCH_RUN_STATUS_RUNINT)//运行状态
	{
		HaveResult = false;
		m_DCNodesMap.clear(); 
		m_ShortCutAreaTrians.clear();
		m_DCNodesMap=m_DCFixNodesMap;
		AdjustFixNodeRect(m_DCNodesMap);//m_DCNodesMap电力相关节点
		CreateTrainNode();//生成列车节点并对其进行初始化，主要为其增加上下行数据
		CalculRectArray();//计算整流器数组  //节点电压法计算 xyx注释
	}
}
bool DCSysMG::UpdataTrainData(DCSysTrain& Train)			//更新列车数据
{//根据当前的列车信息更新列车数据
	m_CritilSec.lock();
	if (IsTrainInPowerStation(Train))//判断列车是否在受电
	{
		map<int,DCSysTrain>::iterator iter =TrainSInStationMap.find(Train.ID);
		if (iter!=TrainSInStationMap.end())
		{
			TrainSInStationMap.erase(Train.ID);   //先将列车的旧数据整体删除，再将列车的最新数据整体重新添加 xyx注释
		}
		TrainSInStationMap.insert(make_pair(Train.ID,Train));  //如果列车已在线上正常（受电弓有电）运行，则更新列车运行状态
		m_CritilSec.unlock();
		return true;
	}
	else
	{
		map<int,DCSysTrain>::iterator iter =TrainSInStationMap.find(Train.ID);
		if (iter!=TrainSInStationMap.end())
		{
			TrainSInStationMap.erase(Train.ID);  //如果列车在线上但未正常（受电弓）运行，则需把列车删除现有列车列表
		}
		m_CritilSec.unlock();
		return false;
	}
}
bool DCSysMG::IsTrainInPowerStation(DCSysTrain& Train)		//判断列车是否在受电
{
	if (OCC_TRAIN_POWERBOW_STATUS_ON==Train.powerbowstatus)//受电弓状态的判断
	{
		string touchnet = GetTouchNetByPosition(Train.LineSectionID,Train.excursion);
		TOUCHNETMAP::iterator iter;
		try
		{
			//string ST = GetTouchNetByPosition(Train.LineSectionID,Train.excursion);
			if (TouchNetMap.size()>0 /*&&*/ /*(touchnet!=_T("") || touchnet !=0)*/)
			{
				int a = TouchNetMap.size();
				if (a == 0)
				{
					return false;
				}
				iter = TouchNetMap.find(touchnet);
			}
			else
			{
				int a = 1;
				return false;
			}
		}
		catch (...)
		{
			return false;
		}

		//通过列车区域ID和列车偏移精度来获取列车在接触网的位置
		if (iter!=TouchNetMap.end()/*&&iter->second->GetBaseType()==OCC_EQPMTTYPE_TouchNet*/)//类型判断-接触网线
		{
			Train.arrow = iter->second->GetRunDirection();//根据接触网线的状态来判断列车的运行方向，进而判断和指定车的方向
			return true;
		}
	}
	return false;
}

void DCSysMG::CheckSpanNetInfo()
{
	DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.begin();
	for (;iter!=m_PowerStationNodeMap.end();iter++)
	{
		ELEEQPMTMAP:: iterator itEqpmtUp = ElectricEqpmtMap.find(iter->second.GetOverZoneUpSwitchID());
		if (itEqpmtUp!=ElectricEqpmtMap.end())
		{
			if (itEqpmtUp->second->GetPower())
			{
				AddSpanNetInfo(iter->second.GetID(),-1,TRAIN_DIR_UP);
			}
		}

		ELEEQPMTMAP:: iterator itEqpmtDown = ElectricEqpmtMap.find(iter->second.GetOverZoneDownSwitchID());
		if (itEqpmtDown!=ElectricEqpmtMap.end())
		{
			if (itEqpmtDown->second->GetPower())
			{
				AddSpanNetInfo(iter->second.GetID(),-1,TRAIN_DIR_DOWN);
			}
		}
		
		//xyx新增begin 根据直流进线开关状态确定是否添加越区节点信息
		bool BreakerPower1=true;
		bool BreakerPower2=true;
		ELEEQPMTMAP:: iterator iterDCInputBreaker1 = ElectricEqpmtMap.find(iter->second.GetFirstDCInputBreakerUnitID());
		if (iterDCInputBreaker1!=ElectricEqpmtMap.end())
		{
			ELEEQPMTMAP:: iterator iterDCInputBreaker2 = ElectricEqpmtMap.find(iter->second.GetSecondDCInputBreakerUnitID());
			if (iterDCInputBreaker2!=ElectricEqpmtMap.end())
			{
				if ( (!iterDCInputBreaker1->second->GetPower())&& !(iterDCInputBreaker1->second->GetPower())  )
				{
					AddSpanNetInfo(iter->second.GetID(),-1,-1);
				}
			}
		}
		//xyx新增end
	}
}

void DCSysMG::DeleteSpanNetInfo()
{
	DCSTATIONMAP::iterator iter = m_PowerStationNodeMap.begin();
	for (;iter!=m_PowerStationNodeMap.end();iter++)
	{
		ELEEQPMTMAP:: iterator itEqpmtUp = ElectricEqpmtMap.find(iter->second.GetOverZoneUpSwitchID());
		if (itEqpmtUp!=ElectricEqpmtMap.end())
		{
			if (itEqpmtUp->second->GetPower())
			{
				RemoveSpanNetInfo(iter->second.GetID(),-1,TRAIN_DIR_UP);
			}
		}

		ELEEQPMTMAP:: iterator itEqpmtDown = ElectricEqpmtMap.find(iter->second.GetOverZoneDownSwitchID());
		if (itEqpmtDown!=ElectricEqpmtMap.end())
		{
			if (itEqpmtDown->second->GetPower())
			{
				RemoveSpanNetInfo(iter->second.GetID(),-1,TRAIN_DIR_DOWN);
			}
		}
	}
}