SCADATrainSys/CCGDServer/ElectricityVOC/BaseElectricEqpmt.cpp

#include "pch.h"
#include "BaseElectricEqpmt.h"
#include "PublicEqpmtID.h"
#include "YD_Public_OCC.h"
#include "ElectricEqpmt_PowerBolt.h"

static  int m_AlarmID=0;
TrackRelationXDMAP BaseElectricEqpmt::m_TrackRelationXDMap;
ErrorToProtectMAP BaseElectricEqpmt::m_mapErrorToProtect;
CALLBACKFUNC_Telesignalisation BaseElectricEqpmt::m_hCallBackTelesignalisation = nullptr;
void* BaseElectricEqpmt::m_pTelesignalisationOwner = nullptr;
CALLBACKFUNC_DealElcTurnOffArea BaseElectricEqpmt::m_hCallBackDealElcTurnOffArea = nullptr;
//int BaseElectricEqpmt::m_nCtrlMark = 0;
CALLBACKFUNC_Deal400VLoadTurnOff BaseElectricEqpmt::m_hCallBackDeal400VLoadTurnOff = nullptr;
ELCEQPMTALARMINFOMAP* BaseElectricEqpmt::m_EqpmtAlarmInfoMap;

BaseElectricEqpmt::BaseElectricEqpmt()
{
	//m_type = 0;
	//m_nRegion =0;
	m_OperStationID = -1;
	m_OperSubsysID = -1;
	m_OperViewID = -1;
	//m_TrackPower = -;
	//m_PreTrackPower;
	m_nRelationElcTurnOffArea = -1;
	m_nCurProtectID = -1;
	//CtrlArea=ELC_EQPMTCTRL_REMOTE;
	SetBaseType(0);
	SetSubType(-1);
	SetRegion(0);
	IsProhibitedReversion = false;
	isReallyEqpmt = false;
	isRealEqpmtFeedback = false;
	m_nRealEqpmtStatus = -1;
	m_nCtrlMark = 0;
	m_nDelaydurTime = Auto_CtrlExecution_Time;
}

//mod by yangs
//新增整形参数 nDesSysID:消息指定发送系统ID
//将状态变化更新到客户端
 void BaseElectricEqpmt::UpdateEqpmtStatus(ELEEQPMTMAP& eqpmtmap,int status,int ctrltype,int nDesSysID)
 {
	 printf("-------------ElectricityVOC-BaseElectricEqpmt-UpdateEqpmtStatus--------------------\r");
	 printf("-------------ElectricityVOC-BaseElectricEqpmt-UpdateEqpmtStatus-Timer: %d--------------------\r", GetSys_SecondTime_2());
	 //m_status=status;
	 if (p_SendList!=nullptr)
	 {
		 if (MRunLineID == 200)
		 {
		 } 
		 //else if(MRunLineID == 300 ||MRunLineID == 400 )//chenht
		 {
			  //1.向行调更新接触网/轨带电状态
			 TrackRelationXDMAP::iterator iteTrackRelaXD = m_TrackRelationXDMap.find(GetEqpmentID());
			 // iteTrackRelaXD = m_TrackRelationXDMap.find(m_strid);
			 if (iteTrackRelaXD != m_TrackRelationXDMap.end())
			 {
				 if (GetStatus()!= status)
				 {
					 //m_PreTrackPower = iteTrackRelaXD->second->m_IsPower;
					 //m_TrackPower = updatadata.Status;
					 //m_TrackRelationXD.m_PreIsPower = iteTrackRelaXD->second->m_IsPower;
					 m_TrackRelationXD.m_PreIsPower = GetStatus();
					 m_TrackRelationXD.m_strID = GetEqpmentID();
					 m_TrackRelationXD.m_IsPower = status;
					 m_TrackRelationXD.m_NoID = iteTrackRelaXD->second->m_NoID;
					 m_TrackRelationXD.m_Direction = iteTrackRelaXD->second->m_Direction;

					 //iteTrackRelaXD->second->m_IsPower = updatadata.Status;

					 COMMANDTOXD cmdtoxd;
					 cmdtoxd.type			= DDTOXD_ELCTRACK_STATUS;
					 cmdtoxd.ObjectID		= iteTrackRelaXD->second->m_NoID;
					 cmdtoxd.data1			= status;
					 cmdtoxd.data2			= iteTrackRelaXD->second->m_Direction;

					 OCCCOMMAND tmpSendOC;				
					 tmpSendOC.cmdType				= OCCCOMMAND::CmdType::eCommantoXD;
					 tmpSendOC.DesSysType			= OCC_SYS_XD_SVR;
					 tmpSendOC.ScrSysType			= OCC_SYS_DD_SVR;
					 tmpSendOC.TrainningID			= m_Trianid;
					 tmpSendOC.DateLen				= sizeof(COMMANDTOXD);
					 tmpSendOC.Net_LS_CommandtoXD	= cmdtoxd;
					 p_SendList->push(tmpSendOC);
				 }
			 }
		 }
	
		 //2.更新设备状态
		 //add by chenht 更具控制类型分别设置挂牌和状态
		 switch(ctrltype)
		 {
		 case CTRLTYPE_CARD:
			 {
				 SetCardStatus(status);
				 break;
			 }
		 case CTRLTYPE_STATUS:
			 {
				 SetStatus(status);
				 break;
			 }
		 }
		 //mod by yangs 控制分合闸时，在状态更新前进行自投分闸处理
		 if (CTRLTYPE_STATUS == ctrltype)
		 {
			 CheckMotherAutoBolt(eqpmtmap);
		 }
		 //added by zhangjiahua
		 DHEQPMTUPDATE updatadata;

		 updatadata.CtrlLock=GetControlLock();
		 updatadata.FaultLock=GetFaultLockStatus();
		 updatadata.RemoteLock=GetRemoteLockStatus();
		 updatadata.CommunicationStaus=GetCommunicationStatus();
		 updatadata.CtrlArea=GetControlArea();

		 updatadata.CtrlType = ctrltype;
		 //updatadata.Status= GetStatus();
		 updatadata.Status= status;

		 updatadata.Category = GetBaseType();
		 updatadata.SubSys = ISCS_SUBSYS_TYPE_ELC;
		 string strID=GetEqpmentID();

		 strncpy(updatadata.EqpmtStrID, strID.c_str(), sizeof(updatadata.EqpmtStrID));
		 string strName=GetEqpmentName();
		 strncpy(updatadata.EqpmtName,strName.c_str(), sizeof(updatadata.EqpmtName));
		 updatadata.StationID = GetStationID();
		 updatadata.ViewID = GetViewID();
		 OCCCOMMAND tmpSendHC;
		 tmpSendHC.setPacketValue(&updatadata,OCCCOMMAND::eUpdateEqpmtStatus);
		 //没有指定系统ID发送则向全部客户端发送
		 if (nDesSysID == 0)
		 {
			tmpSendHC.DesSysType=OCC_SYS_DD_CLIENT;
		 }
		 else
		 {
			tmpSendHC.DesSysType=OCC_SYS_SERVER_SETSYS;
			tmpSendHC.DesNetID=nDesSysID;
		 }
		 tmpSendHC.TrainningID = m_Trianid;
		 tmpSendHC.ScrSysType=OCC_SYS_DD_SVR;
		 p_SendList->push(tmpSendHC);

		 //2.更新控制结果
		 DHSVRREPLY CheckReplyMsg;
		 string retstr;
		 memset(CheckReplyMsg.ReplyText,0,ALARM_LEN);
		 int autoboldstatus = -1;
		 int ctrlLock = -1;
		 ELEEQPMTMAP::iterator itereqpmt = eqpmtmap.find(GetEqpmentID()); 
		 if (itereqpmt->second != nullptr && itereqpmt->second->GetBaseType() == OCC_EQPMTTYPE_AUTOBOLT)
		 {
			 autoboldstatus = itereqpmt->second->GetStatus();				
		 }
		 if (itereqpmt->second != nullptr && (itereqpmt->second->GetBaseType() == OCC_EQPMTTYPE_35kVBREAKER 
			 || itereqpmt->second->GetBaseType() == OCC_EQPMTTYPE_400vACControlBreaker || itereqpmt->second->GetBaseType() == OCC_EQPMTTYPE_BREAKER_DC))
		 {
			 ctrlLock = itereqpmt->second->GetControlLock();
		 }
		 if (m_Trianid>0 && (autoboldstatus != -1 || ctrlLock != -1))
		 {
			 if (autoboldstatus == -1)
			 {
				 autoboldstatus = 1;
			 }
			 CheckReplyMsg.AutoBoltStatus = autoboldstatus;
			 CheckReplyMsg.CtrlLock = ctrlLock;

			 string strID=GetEqpmentID();
			 CheckReplyMsg.CmdID = OCCCOMMAND::eUpdateOperCheck;
			 strncpy(CheckReplyMsg.EqpmtStrID,strID.c_str(), sizeof(CheckReplyMsg.EqpmtStrID));
			 //CheckReplyMsg.CtrlLock=CtrlLockStatus;
			 //CheckReplyMsg.StdID = stdid;
			 //CheckReplyMsg.EqpmtStatus =retstatus;  //100表示通过，101拒绝
			 CheckReplyMsg.StationID=m_OperStationID;
			 CheckReplyMsg.ViewID = m_OperViewID;
			 CheckReplyMsg.SubSysID = m_OperSubsysID; 
			
			 OCCCOMMAND NetOrder;
			 //没有指定系统ID发送则向全部客户端发送
			 if (nDesSysID == 0)
			 {
				 tmpSendHC.DesSysType=OCC_SYS_DD_CLIENT;
			 }
			 else
			 {
				 tmpSendHC.DesSysType=OCC_SYS_SERVER_SETSYS;
				 tmpSendHC.DesNetID=nDesSysID;
			 }
			 NetOrder.ScrSysType = OCC_SYS_DD_SVR;
			 NetOrder.TrainningID = m_Trianid;
			 NetOrder.setPacketValue(&CheckReplyMsg,OCCCOMMAND::eUpdateSvrReply);
			 p_SendList->push(NetOrder);
		 }


		 //m_PreTrackPower = 
		// TrackRelationXDMAP::iterator iteTrackRelaXD = m_TrackRelationXDMap.find(m_strid);
		//// iteTrackRelaXD = m_TrackRelationXDMap.find(m_strid);
		// if (iteTrackRelaXD != m_TrackRelationXDMap.end())
		// {
		//	 if (iteTrackRelaXD->second->m_IsPower != updatadata.Status)
		//	 {
		//		 //m_PreTrackPower = iteTrackRelaXD->second->m_IsPower;
		//		 //m_TrackPower = updatadata.Status;
		//		 m_TrackRelationXD.m_PreIsPower = iteTrackRelaXD->second->m_IsPower;
		//		 m_TrackRelationXD.m_strID = m_strid;
		//		 m_TrackRelationXD.m_IsPower = updatadata.Status;

		//		//iteTrackRelaXD->second->m_IsPower = updatadata.Status;
		//	 }

		// } 
	 }
	 CheckElcEnvirRelation();
	 InitiativeUnionCtrl(status,eqpmtmap);
	 //mod by yangs 函数提前，在更新状态前进行自投逻辑判断处理
	 //CheckMotherAutoBolt(eqpmtmap);

	 // 处理合闸、分闸遥信
	 DealTelesignalisation( GetStatus(), GetEqpmentID(), 1);
	 DealTelesignalisation( !GetStatus(), GetEqpmentID(), 0);

	 if(m_nCurProtectID==10000)
	 {
		DealTelesignalisation( m_nCurProtectID, GetEqpmentID(), 0);
	 }
	 else if ( m_nCurProtectID > 0 /*&& GetStatus()*/ )
	 {
		 DealTelesignalisation( m_nCurProtectID, GetEqpmentID(), 0);
	 }

 }

 void BaseElectricEqpmt::UpdateCommmunicationStatus(int status)
 {
	 if (GetCommunicationStatus()!=status)
	 {
		 //m_nCommunicationStatus=status;
		 SetCommunicationStatus(status);
	 }
 }

 void BaseElectricEqpmt::CutCommunication(map<string,BaseElectricEqpmt*>& ElectricEqpmtMap)
 {
	 UpdateCommmunicationStatus(1);
	 UpdateEqpmtStatus(ElectricEqpmtMap,GetStatus());
	 //xyx屏蔽begin 
	 //string text;
	 //text.Format(" %s %s 通讯中断",GetBaseTypeName(),GetEqpmentName());
	 //SendMsgNotice(GetSourceStationID(),ISCS_SUBSYS_TYPE_ELC,3,DH_MSGCATEGORY_SOE,text);
	 //xyx屏蔽end

	 //xyx修改begin
	 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
	 string EqpmtName = GetEqpmentName();                 //设备名称
	 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
	 int     EqpmtType = GetBaseType();                    //设备类型
	 int nActType = ElcAlarm_TripActType_Comloss;          //“通讯中断”报文类型
	 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
	 //xyx修改end
 }

 void BaseElectricEqpmt::RevertCommunication(map<string,BaseElectricEqpmt*>& ElectricEqpmtMap)
 {
	 UpdateCommmunicationStatus(0);
	 UpdateEqpmtStatus(ElectricEqpmtMap,GetStatus());
	 
	 //xyx屏蔽begin
	 //string text;
	 //text.Format(" %s %s 通讯恢复",GetBaseTypeName(),GetEqpmentName());
	 //SendMsgNotice(GetSourceStationID(),ISCS_SUBSYS_TYPE_ELC,2,DH_MSGCATEGORY_SOE,text);
	 //xyx屏蔽end

	 //xyx修改begin
	 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
	 string EqpmtName = GetEqpmentName();                 //设备名称
	 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
	 int     EqpmtType = GetBaseType();                    //设备类型
	 int     nActType = ElcAlarm_TripActType_ComRecovery;  //“通讯恢复”报文更新
	 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
	 //xyx修改end
 }

 //设备报警
 void BaseElectricEqpmt::CutEqpmtAlarm(map<string,BaseElectricEqpmt*>& ElectricEqpmtMap, int nTripActType)
 {
	 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
	 string EqpmtName = GetEqpmentName();                 //设备名称
	 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
	 int     EqpmtType = GetBaseType();                    //设备类型
	 int     nActType = nTripActType;  //“设备报警”报文更新
	 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
 }
 //设备报警恢复
 void BaseElectricEqpmt::RevertEqpmtAlarm(map<string,BaseElectricEqpmt*>& ElectricEqpmtMap, int nTripActType)
 {
	 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
	 string EqpmtName = GetEqpmentName();                 //设备名称
	 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
	 int     EqpmtType = GetBaseType();                    //设备类型
	 int     nActType = nTripActType;  //“设备报警恢复”报文更新
	 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
 }

 void BaseElectricEqpmt::AddCtrlUnoin(int operstatus,string preeqpmtid,int prestatus,int relation,int delaytime,int index)
 {
	 UionCtrl ctrlunion;
	 ctrlunion.Sourceid = GetEqpmentID();
	 ctrlunion.OperStatus = operstatus;
	 ctrlunion.PreEqpmtID = preeqpmtid;
	 ctrlunion.PreStatus = prestatus;
	 ctrlunion.Relation = relation;
	 ctrlunion.delaytime = delaytime;
	 ctrlunion.Index = index;


	 m_CtrlUnions.push_back(ctrlunion);
 }

 void BaseElectricEqpmt::InitiativeUnionCtrl(int status,ELEEQPMTMAP& ElectricEqpmtMap)
 {
	 for (size_t i=0;i<m_CtrlUnions.size();i++)
	 {
		 if (m_CtrlUnions[i].Sourceid==GetEqpmentID()&&m_CtrlUnions[i].OperStatus==status&&m_CtrlUnions[i].Relation==EQPMT_RELATIONTYPE_INITUIONCTRL)
		 {
			 ELEEQPMTMAP::iterator iter = ElectricEqpmtMap.find(m_CtrlUnions[i].PreEqpmtID);
			 if (iter!=ElectricEqpmtMap.end())
			 {
				 DelayTimeInfo delay;
				 delay.type=Auto_DelayTime_InitCtrl;
				 delay.delaydur=m_CtrlUnions[i].delaytime;
				 delay.occartime = GetNumTime_Second_2();
				 delay.srcid = GetEqpmentID();
				 delay.srcstatus = status;
				 delay.desid =m_CtrlUnions[i].PreEqpmtID;
				 delay.destatus = m_CtrlUnions[i].PreStatus;
				 p_DelayTimeMap->insert(make_pair(m_CtrlUnions[i].PreEqpmtID,delay));
			 }
		 }
	 }
 }

 void BaseElectricEqpmt::OccarSearchError(int errorid)
{
 	ERRORMAP::iterator iter = m_CurErrorNos.find(errorid);
 	if (iter==m_CurErrorNos.end())
 	{
 		ErrorInfo errorinfo;	
 		errorinfo.ID = errorid;
 		errorinfo.Status = Electric_Fault_Status_Start;
 		m_CurErrorNos.insert(make_pair(errorid,errorinfo));
 	}
}

void BaseElectricEqpmt::SendMsgNotice(int station,int sysid,int level,int type, int fault, string labelvalue,string strEqpmtID/* = _T("")*/)
{
	if (p_SendList!=nullptr)
	{		
		DHMSGNOTICE DHNotice;
		DHNotice.StationID = station;
		DHNotice.Time = GetNumTime_Second_2();
		DHNotice.RegionID = ISCS_SUBSYS_TYPE_ELC;
		DHNotice.Type = type;
		DHNotice.Level =level;
		strncpy(DHNotice.LabelValue, labelvalue.c_str(), sizeof(DHNotice.LabelValue));
		strncpy(DHNotice.EqpmtID, strEqpmtID.c_str(), sizeof(DHNotice.EqpmtID));
		OCCCOMMAND NetOrder;
		NetOrder.DesSysType = OCC_SYS_DD_CLIENT;
		NetOrder.ScrSysType = OCC_SYS_DD_SVR;
		NetOrder.TrainningID = m_Trianid;
		NetOrder.setPacketValue(&DHNotice,OCCCOMMAND::eUpdateDHMsgNotice);
		p_SendList->push(NetOrder);
	}
}

void BaseElectricEqpmt::RevertAlarms()
{
	for (size_t i =0;i<m_AlarmIDs.size();i++)
	{
		if (p_SendList!=nullptr)
		{
 			ALARMREVERT RevertNotice;
 			RevertNotice.AlarmID = m_AlarmIDs[i];
 			OCCCOMMAND NetOrder;
 			NetOrder.DesSysType = OCC_SYS_DD_CLIENT;
 			NetOrder.ScrSysType = OCC_SYS_DD_SVR;
 			NetOrder.TrainningID = m_Trianid;
 			NetOrder.setPacketValue(&RevertNotice,OCCCOMMAND::eUpdateAlarmRevert);
 			p_SendList->push(NetOrder);
		}

	}
	m_AlarmIDs.clear();

}
BaseElectricEqpmt:: ~BaseElectricEqpmt()
{

}
 bool BaseElectricEqpmt::PowerIn(ELEEQPMTMAP& eqpmtmap,string sourceid)		//使与sourceid相关的电力元件全部通电
 {
	 /*std::map<string,string>::iterator iter = OutputEqpmtIDMap.begin();
	 for (;iter!=OutputEqpmtIDMap.end();iter++)
	 {
		 ELEEQPMTMAP::iterator iter_Output=eqpmtmap.find(iter->first);
		 if (iter_Output!=eqpmtmap.end())
		 {
			 if (!iter_Output->second->GetPower()&&iter_Output->second->GetControlType()==Electric_Eqpmt_CtrlType_Auto)
			 {
				 iter_Output->second->UpdateEqpmtStatus(eqpmtmap,Electric_Eqpmt_Status_ON);
				 iter_Output->second->SetPower(true);
				 iter_Output->second->PowerIn(eqpmtmap,iter_Output->second->GetEqpmentID());
			 }
			 else if (!iter_Output->second->GetPower()&&iter_Output->second->GetControlType()==Electric_Eqpmt_CtrlType_Mannual&&iter_Output->second->GetStatus()==Electric_Eqpmt_Status_ON)
			 {
				 iter_Output->second->SetPower(true);
				 iter_Output->second->PowerIn(eqpmtmap,iter_Output->second->GetEqpmentID());
			 }
		 }
	 }
	 DealElcTurnOffArea();
	 return true;*/

	 INPUTEQPMTMAP::iterator iter = InputEqpmtIDMap.begin();	//BaseElectricEqpmt实体为sourceid的输出设备，InputEqpmtIDMap为sourceid的输出设备的输入设备
	 for (;iter!=InputEqpmtIDMap.end();iter++)
	 {
		 if (sourceid==iter->first)		//在输入设备列表中查找与sourceid一致的电力元件
		 {
			 if (iter->second.InputPower)
			 {
				 return false;
			 }
			 iter->second.InputPower = true;	

			 SetPower(true);
			 UpdateEqpmtStatus(eqpmtmap,Electric_Eqpmt_Status_ON);
		 }
	 }
	 OUTPUTEQPMTMAP::iterator iter2 = OutputEqpmtIDMap.begin();	//OutputEqpmtIDMap为sourceid的输出设备的输出设备
	 for (;iter2!=OutputEqpmtIDMap.end();iter2++)
	 {
		 if (iter2->first!=sourceid)				//在输出设备列表中查找与sourceid不一致但在eqpmtmap表中的数据，如果能找到相应数据，则此数据为相关输出设备
		 {
			 ELEEQPMTMAP::iterator iter3 = eqpmtmap.find(iter2->first);
			 if (iter3!=eqpmtmap.end())
			 {
				 iter3->second->PowerIn(eqpmtmap,GetEqpmentID());		//设置相关输出设备元件有电
			 }
		 }
	 }
	 DealElcTurnOffArea();
	 return true;

 }
 bool BaseElectricEqpmt::PowerLost(ELEEQPMTMAP& eqpmtmap,string sourceid,int offcase)	//改变电力元件设备状态并送客户端（UpdateEqpmtStatus），更改电力元件受电失电标志（PowerCut）
 {
	 /*if (GetControlType()==Electric_Eqpmt_CtrlType_Auto)
	 {
		 UpdateEqpmtStatus(eqpmtmap,Electric_Eqpmt_Status_OFF);			//如果为自动控制设备，将受电失电的颜色状态状态改变，即完成电力元件的状态改变

	 }
	 SetPower(false);
	 OUTPUTEQPMTMAP::iterator iter = OutputEqpmtIDMap.begin();		//OutputEqpmtIDMap为sourceid的输出设备
	 for (;iter!=OutputEqpmtIDMap.end();iter++)
	 {
		 ELEEQPMTMAP::iterator iter1 = eqpmtmap.find(iter->first);	//查找eqpmtmap列表中是否存在输出设备列表中的电力元件，如存在则表明eqpmtmap表中有要停电的电力元件
		 if (iter1==eqpmtmap.end())
			 continue;
		 if (iter1->second->GetEqpmentID()==GetEqpmentID())
		 {
			 continue;
		 }
		 //iter1->second->PowerCut(eqpmtmap,m_strid,offcase);		//使相应的电力元件停电  //PowerCut完成是否通电，维护InputLineInfo这个数据结构
		 if (iter1->second->GetPower())
		 {
			 if (iter1->second->PowerCut(eqpmtmap,GetEqpmentID(),offcase))
			 {
				 //PowerLost(eqpmtmap,iter1->second->GetStrID(),offcase);
				 string a=iter1->first;
				 bool b=false;
				 if (a=="{8CD21152-DB65-4EF8-993E-585E935D21F6}")
				 {
					 b=true;
				 }
				 iter1->second->PowerLost(eqpmtmap,iter1->second->GetEqpmentID(),offcase);
			 }
		 }
	 }*/
	 SetPower(false);
	 UpdateEqpmtStatus(eqpmtmap,Electric_Eqpmt_Status_OFF);			//将受电失电的颜色状态状态改变，即完成电力元件的状态改变
	 OUTPUTEQPMTMAP::iterator iter = OutputEqpmtIDMap.begin();		//OutputEqpmtIDMap为sourceid的输出设备
	 for (;iter!=OutputEqpmtIDMap.end();iter++)
	 {
		 ELEEQPMTMAP::iterator iter1 = eqpmtmap.find(iter->first);	//查找eqpmtmap列表中是否存在输出设备列表中的电力元件，如存在则表明eqpmtmap表中有要停电的电力元件
		 if (iter1==eqpmtmap.end())
			 continue;
		 iter1->second->PowerCut(eqpmtmap,GetEqpmentID(),offcase);		//使相应的电力元件停电  //PowerCut完成是否通电，维护InputLineInfo这个数据结构
	 }

	 DealElcTurnOffArea();
	 return true;
 }
bool BaseElectricEqpmt::CheckElcEnvirRelation()
{
	if (p_SendList!=nullptr)
	{
		for (int i=0;i < m_ElcEnvirRelations.size();i++)
		{
 			ELCENVIRRELATION EnvirPower;
			string strID=GetEqpmentID();
			strncpy(EnvirPower.EqpmtStrID, strID.c_str(), sizeof(EnvirPower.EqpmtStrID));
 			EnvirPower.EnvirArea = m_ElcEnvirRelations[i].EnvirAreaID;
 			EnvirPower.EqpmtStatus = GetStatus();
 			strncpy(EnvirPower.AreaName, m_ElcEnvirRelations[i].Areaname.c_str(), sizeof(EnvirPower.AreaName));
 			OCCCOMMAND NetOrder;
 			NetOrder.DesSysType = OCC_SYS_HD_SVR;
 			NetOrder.ScrSysType = OCC_SYS_DD_SVR;
 			NetOrder.TrainningID = m_Trianid;
 			NetOrder.setPacketValue(&EnvirPower,OCCCOMMAND::eUpdateElcEnvirRelation);
 			p_SendList->push(NetOrder);	
			
		}
	}
	return true;
}
 bool BaseElectricEqpmt::PowerCut(ELEEQPMTMAP& eqpmtmap,string sourceid,int offcase)
 {
	/* bool bIsPowerLost=true;
	 INPUTEQPMTMAP::iterator iter = InputEqpmtIDMap.begin();  //检查设备输入设备是否有电
	 if (InputEqpmtIDMap.size()>1)
	 {
		 for (;iter!=InputEqpmtIDMap.end();iter++)
		 {
			 ELEEQPMTMAP::iterator iter_input=eqpmtmap.find(iter->first);
			 if (iter_input!=eqpmtmap.end())
			 {
				 if (iter_input->second->GetEqpmentID()!=sourceid&&iter_input->second->GetPower())
				 {	
					 if (!iter_input->second->PowerCut(eqpmtmap,GetEqpmentID(),offcase)) //输入设备的输入设备有电，则继续检查输入设备的输入设备的输入设备
					 {
						 //return false; 
						 bIsPowerLost=false;
						 break;
					 }
				 }
				 if (iter_input->second->GetEqpmentID()==sourceid)
				 {
					 continue;
				 }
			 }
		 }
	 }
	 else if (InputEqpmtIDMap.size()==1)
	 {
		 ELEEQPMTMAP::iterator iter_input=eqpmtmap.find(iter->first);
		 if (iter_input!=eqpmtmap.end())
		 {
			 if (iter_input->second->GetEqpmentID()==sourceid)
			 {
				 bIsPowerLost=true;
			 }
		 }	
	 }
	 else if (InputEqpmtIDMap.size()==0&&GetPower())
	 {
		 bIsPowerLost=false;
	 }

	 return bIsPowerLost;*/


	 int count =0;
	 string id="";
	 bool isinput =false;
	 INPUTEQPMTMAP::iterator iter = InputEqpmtIDMap.begin();  //InputEqpmtIDMap为sourceid的输出设备的输入设备列表
	 for (;iter!=InputEqpmtIDMap.end();iter++)
	 {
		 if (sourceid==iter->first)
		 {
			 if (!iter->second.InputPower)
			 {
				 return false;
			 }
			 iter->second.InputPower = false;
			 isinput=true;
		 }
		 if (iter->second.InputPower)
		 {
			 count++;
			 id = iter->first;
		 }
	 }
	 if (!isinput)
		 return false;

	 if (count==1)  //处理电力元件有两个输入的情况
	 {
		 ELEEQPMTMAP::iterator iter3 = eqpmtmap.find(id);
		 if (iter3!=eqpmtmap.end())
		 {
			 iter3->second->PowerCut(eqpmtmap,GetEqpmentID(),offcase);
		 }
	 }
	 if (count<1)  //处理电力元件有三个输入的情况
	 {
		 PowerLost(eqpmtmap,GetEqpmentID(),offcase);
	 }

	 //处理直流侧输入输出逻辑错误 暂屏蔽 yangs
	 //直流母线多输入处理
	 //if (OCC_EQPMTTYPE_1500vDCMLine == GetBaseType())
	 //{
		// //检查带电来源
		// if (CheckDCMLineInPowerNums(eqpmtmap))
		// {
		//	 return true;
		// }
		// //查找输入
		// vector<string> vecInputEqpmtID;
		// vecInputEqpmtID.clear();
		// INPUTEQPMTMAP::iterator iterInput = InputEqpmtIDMap.begin();
		// for (; iterInput != InputEqpmtIDMap.end(); iterInput++)
		// {
		//	 if (iterInput->second.InputPower)
		//	 {
		//		 vecInputEqpmtID.push_back(iterInput->first);
		//	 }
		// }
		// //对输入进行断电检查
		// for (int i = 0; i < vecInputEqpmtID.size(); i++)
		// {
		//	 ELEEQPMTMAP::iterator iter15 = eqpmtmap.find(vecInputEqpmtID[i]);
		//	 if (iter15 != eqpmtmap.end())
		//	 {
		//		 iter15->second->PowerCut(eqpmtmap, GetEqpmentID(), offcase);
		//	 }
		// }
	 //}

	 return true;
 }

 bool BaseElectricEqpmt::PowerCutMLineOutPower(int nType)
 {
	 INPUTEQPMTMAP::iterator iter1 = InputEqpmtIDMap.begin();
	 for (; iter1 != InputEqpmtIDMap.end(); iter1++)
	 {
		 if (iter1->second.InputPower)
		 {
			 //对输入分类统计
			/* ELEEQPMTMAP::iterator iter3 = eqpmtmap.find(iter1->first);
			 if (iter3 != eqpmtmap.end())
			 {
				if (iter3->second->GetSubType() == nType)
				 {
					 iter3->second->PowerCut(eqpmtmap, GetEqpmentID(), offcase);
				 }
			 }*/
		 }
	 }
 }

 bool BaseElectricEqpmt::CheckDCMLineInPowerNums(map<string, BaseElectricEqpmt*>& eqpmtmap)
 {
	 bool bRet = true;
	 int nCount = 0, nLcount = 0, nRcount = 0;
	 INPUTEQPMTMAP::iterator iter1 = InputEqpmtIDMap.begin();
	 for (; iter1 != InputEqpmtIDMap.end(); iter1++)
	 {
		 if (iter1->second.InputPower)
		 {
			 //对输入分类统计
			 ELEEQPMTMAP::iterator iter3 = eqpmtmap.find(iter1->first);
			 if (iter3 != eqpmtmap.end())
			 {
				 //本站1500V进线
				 if (iter3->second->GetSubType() == Electric_PowerLine_Input)
				 {
					 nCount++;
				 }
				 //左邻馈线
				 else if (iter3->second->GetSubType() == Electric_PowerLine_OnTouch_L)
				 {
					 nLcount++;
				 }
				 //右邻馈线
				 else if (iter3->second->GetSubType() == Electric_PowerLine_OnTouch_R)
				 {
					 nRcount++;
				 }
			 }
		 }
	 }
	 //本站1500V进线无电并且左邻馈线或右邻馈线无电
	 if (nCount == 0 && (nLcount == 0 || nRcount == 0))
	 {
		 bRet = false;
	 }
	 return bRet;
 }

int BaseElectricEqpmt::CheckInPowerNums()
{	
 	int count = 0;
 	INPUTEQPMTMAP::iterator iter1 = InputEqpmtIDMap.begin();
 	for (;iter1!=InputEqpmtIDMap.end();iter1++)
 	{
 		if (iter1->second.InputPower)
 		{
 			count++;
 		}
 	}
	return count;
}

bool BaseElectricEqpmt::AddProtect(string id, int EventID )
{
	ProtectCtrl protectCtrl;
	protectCtrl.ProtectStrID = id;
	protectCtrl.EventID = EventID;
	ProtectVecs.push_back(protectCtrl);
	return true;
}


bool BaseElectricEqpmt::handle_fault(int eventOper,ELEEQPMTMAP& eqpmtmap,int errorid, int Param, int nType)
 {
  	OccarSearchError(errorid);
	bool bAlarmFault = true;//仅产生告警故障
  	for (size_t i=0;i<ProtectVecs.size();i++)
  	{
		if ( ProtectVecs[i].EventID == Param )
		{
			ELEEQPMTMAP::iterator iter = eqpmtmap.find( ProtectVecs[i].ProtectStrID );
			if (iter==eqpmtmap.end())
				continue;
			iter->second->handle_checkprotect(eventOper,eqpmtmap,errorid,Param);
			//chenht 使用字段与是否重合闸判断字段冲突
			//if (nType == 2) //该类型故障设备无法复归
			//{
			//	iter->second->setProhibitedReversion();
			//}
			bAlarmFault = false;
		}
  	}
	// 根据故障设备闭锁设备列表闭锁相关设备
	map<string,BaseElectricEqpmt*>::iterator iterEqpmt;
	for ( int i = 0; i < m_ProtectLockingEqpmt.size(); i++ )
	{
		if ( m_ProtectLockingEqpmt[i].EventID == Param )
		{
			iterEqpmt = eqpmtmap.find( m_ProtectLockingEqpmt[i].PreEqpmtID );
			if ( iterEqpmt != eqpmtmap.end() )
			{
				ProtectLocking( iterEqpmt->second, m_ProtectLockingEqpmt[i].strText, m_ProtectLockingEqpmt[i].EventID);
			}
		}
	}
	// 根据故障场景闭锁设备列表闭锁相关设备
	for (int i = 0; i < m_vecFaultSceneLockingEqpmt.size(); i++)
	{
		if (m_vecFaultSceneLockingEqpmt[i].EventID == Param)
		{
			iterEqpmt = eqpmtmap.find(m_vecFaultSceneLockingEqpmt[i].PreEqpmtID);
			if (iterEqpmt != eqpmtmap.end())
			{
				FaultSceneLocking(iterEqpmt->second, m_vecFaultSceneLockingEqpmt[i].EventID);
			}
		}
	}
	//只有报警没有设备动作的故障处理
	if (bAlarmFault)
	{
		CutEqpmtAlarm(eqpmtmap,Param);
	}
 	return true;
 }
 bool BaseElectricEqpmt::handle_revert(int eventOper,ELEEQPMTMAP& eqpmtmap,int Param)
 {
#if 0
	 ERRORMAP::iterator iter = m_CurErrorNos.find(Param);
	 if (iter!=m_CurErrorNos.end())
	 {
		 m_CurErrorNos.erase(iter);
		 RevertErrorToProtect(eventOper, eqpmtmap, Param);
		 
		 //xyx屏蔽begin
		 //string text;
		 //text.Format(" %s %s  故障恢复  ",GetBaseTypeName(),GetEqpmentName());
		 //SendMsgNotice(GetSourceStationID(),GetRegion(),4,DH_MSGCATEGORY_SOE,text);
		 //xyx屏蔽end

		 //xyx修改begin
		 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
		 string EqpmtName = GetEqpmentName();                 //设备名称
		 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
		 int     EqpmtType = GetBaseType();					   //设备类型
		 int     nActType = ElcAlarm_TripActType_FualtRecovery;  ////“故障恢复”报文更新
		 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
		 //xyx修改end
	 }
#else
	 if (EraseErrorNosByErrorID(Param))
	 {
		 RevertErrorToProtect(eventOper, eqpmtmap, Param);

		 //xyx屏蔽begin
		 //string text;
		 //text.Format(" %s %s  故障恢复  ",GetBaseTypeName(),GetEqpmentName());
		 //SendMsgNotice(GetSourceStationID(),GetRegion(),4,DH_MSGCATEGORY_SOE,text);
		 //xyx屏蔽end

		 //xyx修改begin
		 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
		 string EqpmtName = GetEqpmentName();                 //设备名称
		 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
		 int     EqpmtType = GetBaseType();					   //设备类型
		 int     nActType = ElcAlarm_TripActType_FualtRecovery;  ////“故障恢复”报文更新
		 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType);
		 //xyx修改end
	 }
#endif
	 return true;
 }

 bool BaseElectricEqpmt::EraseErrorNosByErrorID(int nErrorID)
 {
	 bool bRet = false;
	 ERRORMAP::iterator iter = m_CurErrorNos.find(nErrorID);
	 if (iter!=m_CurErrorNos.end())
	 {
		 m_CurErrorNos.erase(iter);
		 bRet = true;
	 }
	 return bRet;
 }



 void BaseElectricEqpmt::SetTrackRelationXDMap( TrackRelationXDMAP trackrelationmap )
 {
	m_TrackRelationXDMap = trackrelationmap;
 }

 TrackRelationXDMAP BaseElectricEqpmt::GetTrackRelationXDMap()
 {
	return m_TrackRelationXDMap;
 }

 bool BaseElectricEqpmt::CheckErrorToProtect( int eventOper,map<string,BaseElectricEqpmt*>& eqpmtmap, int nErrorid )
 {
	 ErrorToProtectMAP::iterator iterErrorToProtect = m_mapErrorToProtect.find( nErrorid );
	 if ( iterErrorToProtect == m_mapErrorToProtect.end() )
	 {
		 return false;
	 }
	 // 自身是否需要断开
	 if ( iterErrorToProtect->second.bSelfLost )
	 {
		UpdateEqpmtStatus(eqpmtmap,Electric_Eqpmt_Status_OFF);
		PowerLost( eqpmtmap, GetEqpmentID(), Electric_Eqpmt_Status_OFF);
	 }
	 // 遍历保护类型
	for( int i = 0; i < iterErrorToProtect->second.vecProtectClass.size(); i++ )
	{
		handle_fault( eventOper, eqpmtmap, nErrorid, iterErrorToProtect->second.vecProtectClass[i], iterErrorToProtect->second.nErrorType );
	}
	//处理源头设备，否则系统无法正常供电操作 noted by zhnagjiahua
	if (InputEqpmtIDMap.empty() && Electric_Eqpmt_Status_ON == GetStatus())
	{
		UpdateEqpmtStatus(eqpmtmap, Electric_Eqpmt_Status_OFF);
		PowerLost(eqpmtmap, GetEqpmentID(), Electric_Eqpmt_Status_OFF);
	}
 }

 bool BaseElectricEqpmt::RevertErrorToProtect( int eventOper,map<string,BaseElectricEqpmt*>& eqpmtmap, int nErrorid )
 {
	 ErrorToProtectMAP::iterator iterErrorToProtect = m_mapErrorToProtect.find( nErrorid );
	 if ( iterErrorToProtect == m_mapErrorToProtect.end() )
	 {
		 return false;
	 }
	 // 遍历保护类型
	 for( int i = 0; i < iterErrorToProtect->second.vecProtectClass.size(); i++ )
	 {
		 RevertErrorToProtect( eventOper, eqpmtmap, nErrorid, iterErrorToProtect->second.vecProtectClass[i] );
	 }

	 //处理源头设备，否则系统无法正常供电操作 noted by zhnagjiahua
     if ( InputEqpmtIDMap.empty() && Electric_Eqpmt_Status_OFF == GetStatus() )
     {
		 UpdateEqpmtStatus( eqpmtmap,Electric_Eqpmt_Status_ON );
		 PowerIn(eqpmtmap, GetEqpmentID() );
     }
	 // 有输入但是自身断开了的设备
	 else if (iterErrorToProtect->second.bSelfLost && Electric_Eqpmt_Status_OFF == GetStatus())
	 {
		 UpdateEqpmtStatus(eqpmtmap, Electric_Eqpmt_Status_ON);
		 PowerIn(eqpmtmap, GetEqpmentID());
	 }
	 return true;
 }

 bool BaseElectricEqpmt::RevertErrorToProtect( int eventOper,map<string,BaseElectricEqpmt*>& eqpmtmap, int nErrorid, int nProtectID )
 {
	 for (size_t i=0;i<ProtectVecs.size();i++)
	 {
		 if ( ProtectVecs[i].EventID == nProtectID )
		 {
			 ELEEQPMTMAP::iterator iter = eqpmtmap.find(ProtectVecs[i].ProtectStrID);
			 if (iter==eqpmtmap.end())
				 continue;
			 //mode by yangs 20230702
			 //iter->second->ClearProtect(eqpmtmap,nProtectID);
			 iter->second->ClearProtect(eqpmtmap,nErrorid);
			 iter->second->UpdateEqpmtLightCardStatu(-1);
		 }
	 }
	 // 根据故障场景闭锁设备列表解锁相关设备 add by yangs
	 map<string, BaseElectricEqpmt*>::iterator iterEqpmt;
	 for (int i = 0; i < m_vecFaultSceneLockingEqpmt.size(); i++)
	 {
		 if (m_vecFaultSceneLockingEqpmt[i].EventID == nProtectID)
		 {
			 iterEqpmt = eqpmtmap.find(m_vecFaultSceneLockingEqpmt[i].PreEqpmtID);
			 if (iterEqpmt != eqpmtmap.end())
			 {
				 iterEqpmt->second->SetFaultSceneLock(nProtectID, false);
			 }
		 }
	 }
	return true;
 }

 void BaseElectricEqpmt::AddProtectLockingEqpmt( const string& strProtectLockingEqpmtID, int nProtectId,const string& strLockintText )
 {
	UionCtrl protectLockingUion;
	protectLockingUion.Sourceid = GetEqpmentID();
	protectLockingUion.EventID = nProtectId;
	protectLockingUion.PreEqpmtID = strProtectLockingEqpmtID;
	protectLockingUion.strText = strLockintText;
	m_ProtectLockingEqpmt.push_back(protectLockingUion);
 }

 void BaseElectricEqpmt::ProtectLocking( BaseElectricEqpmt* pEqpmt, const string& strLockingDisplayContent ,int nProtectID )
 {
	 if( nullptr == pEqpmt ) return;
	 //xyx屏蔽begin
	 //string strtext;
	 //strtext.Format("%s %s",pEqpmt->GetEqpmentName(), strLockingDisplayContent );
	 //SendMsgNotice(GetSourceStationID(),GetRegion(),1,DH_MSGCATEGORY_SYS,strtext,pEqpmt->GetEqpmentID());
	 //xyx屏蔽end

	 //xyx修改begin
	string EqpmtTypeName = pEqpmt->GetBaseTypeName();            //设备类型名称
	string EqpmtName = pEqpmt->GetEqpmentName();                 //设备名称
	int     EqpmtSourceStatonID = pEqpmt->GetSourceStationID();   //设备所属车站ID
	int     EqpmtType = pEqpmt->GetBaseType();                        //设备类型

	ELCEQPMTALARMINFOMAP::iterator iterAlarmEqpmtType = m_EqpmtAlarmInfoMap->find(EqpmtType);
	if (iterAlarmEqpmtType!=m_EqpmtAlarmInfoMap->end())
	{
		ELCEQPMTALARMACTTYPEMAP mapAlarmActType = iterAlarmEqpmtType->second;
		ELCEQPMTALARMACTTYPEMAP::iterator iterAlarmActType=mapAlarmActType.begin();
		for (;iterAlarmActType!=mapAlarmActType.end();iterAlarmActType++)
		{
			if (nProtectID == iterAlarmActType->first)
			{
				iterAlarmActType->second.m_strProtectLock=strLockingDisplayContent;
				UpdateAlarmInfo(EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,iterAlarmActType->second); 
				//更新闭锁设备的闭锁状态 add by chenht 2020-1222	
				pEqpmt->SetFaultLockStatus(Electric_Eqpmt_Status_Lock);
			}
		}
	}
	 //xyx修改end
	//更新闭锁设备的闭锁状态 add by chenht 2020-1222	
	pEqpmt->SetFaultLockStatus(Electric_Eqpmt_Status_Lock);
 }

 void BaseElectricEqpmt::AddFaultSceneLockingEqpmt(const string& strProtectLockingEqpmtID, int nProtectId)
 {
	 FaultSceneCtrl faultsceneLocking;
	 faultsceneLocking.Sourceid = GetEqpmentID();
	 faultsceneLocking.EventID = nProtectId;
	 faultsceneLocking.PreEqpmtID = strProtectLockingEqpmtID;
	 m_vecFaultSceneLockingEqpmt.push_back(faultsceneLocking);
 }

 void BaseElectricEqpmt::FaultSceneLocking(BaseElectricEqpmt* pEqpmt, int nProtectID)
 {
	 if(nullptr == pEqpmt) return;

	//更新故障场景设备闭锁 add by yangs	
	 pEqpmt->SetFaultSceneLock(nProtectID,true);
 }

 void BaseElectricEqpmt::CheckMotherAutoBolt(map<string,BaseElectricEqpmt*>& eqpmtmap)
 {
	 //非备自投又没有关联备自投 即其他断路器
	 if ( m_strMotherAutoBolt.empty() )
	 {
		 return;
	 }
	 ELEEQPMTMAP::iterator iterbolt = eqpmtmap.find(m_strMotherAutoBolt);
	 //没有找到关联的备自投
	 if ( iterbolt == eqpmtmap.end() )
	 {
		 return;
	 }

	 ElectricEqpmt_PowerBolt* pbolt= (ElectricEqpmt_PowerBolt*)iterbolt->second;
	 if ( nullptr != pbolt )
	 {
		 pbolt->CheckSelfShut( eqpmtmap,pbolt->GetRelationBreaker() );
	 }
 }

 bool BaseElectricEqpmt::AddFaultEqpmt(string FaultEqpmt)
 {
	 vector<string>::iterator vec;
	 vec=find(m_FaultEqpmt.begin(),m_FaultEqpmt.end(),FaultEqpmt);
	 if (vec==m_FaultEqpmt.end())
	 {
		 m_FaultEqpmt.push_back(FaultEqpmt);
	 }
	 return true;
 }

 void BaseElectricEqpmt::DealTelesignalisation( int nProtectID, const string& strEqpmtStrID, int nMark  )
 {
	if ( nullptr != m_hCallBackTelesignalisation )
	{
		m_hCallBackTelesignalisation( m_pTelesignalisationOwner, nProtectID, strEqpmtStrID, nMark );
		if ( nProtectID > 1 )
		{
			if ( nMark )
			{
				m_nCurProtectID = nProtectID;
			}
			else
			{
				m_nCurProtectID = -1;
			}
		}
	}
 }

 void BaseElectricEqpmt::DealElcTurnOffArea()
 {
	Deal400VLoad();
	 if ( m_nRelationElcTurnOffArea < 0 )
	 {
		 return;
	 }
	if ( nullptr != m_hCallBackDealElcTurnOffArea )
	{
		m_hCallBackDealElcTurnOffArea( m_pTelesignalisationOwner, GetEqpmentID() );
	}
 }

 void BaseElectricEqpmt::Deal400VLoad()
 {
	 if ( m_n400VLoadID > 0 && nullptr != m_hCallBackDeal400VLoadTurnOff )
	 {
		 m_hCallBackDeal400VLoadTurnOff( m_pTelesignalisationOwner, GetEqpmentID(), m_n400VLoadID );
	 }
 }

 bool BaseElectricEqpmt::IsPower()
 {
	return GetPower();
 }

 void BaseElectricEqpmt::ElcAreaAlarm(  bool bPower )
 {
	 //xyx屏蔽begin
	 //string strPower;
	 //if ( bPower )
	 //{
		// strPower = _T("线路带电");
	 //}
	 //else
	 //{
		// strPower = _T("线路失电");
	 //}
	 //string strText;
	 //strText.Format( "%s %s %s", GetBaseTypeName(), GetEqpmentName(), strPower);
	 //SendMsgNotice(GetSourceStationID(),GetRegion(),1,DH_MSGCATEGORY_SYS,strText,GetEqpmentID());
	 //xyx屏蔽end

	 //xyx修改begin
	 string EqpmtTypeName = GetBaseTypeName();            //设备类型名称
	 string EqpmtName = GetEqpmentName();                 //设备名称
	 int     EqpmtSourceStatonID = GetSourceStationID();   //设备所属车站ID
	 int     EqpmtType = GetBaseType();                    //设备类型
	 if ( bPower )
	 {
		 int nActType1 = ElcAlarm_TripActType_TransLineLosePower;    //“线路失电”报文类型
		 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType1);
	 }
	 else
	 {
		 int nActType2 = ElcAlarm_TripActType_TransLineOnPower;    //“线路带电”报文类型
		 UpdateAlarmType(EqpmtType,EqpmtTypeName,EqpmtName,EqpmtSourceStatonID,nActType2);
	 }
	 //xyx修改end
 }

 void BaseElectricEqpmt::AddOutLineElectricEqpmt( int nType, const string& strOutLineElectricEqpmtStrID )
 {
	m_vecOutLineElectricEqpmt.push_back( OutLineElectricEqpmt(nType, strOutLineElectricEqpmtStrID) );
 }

 void BaseElectricEqpmt::CheckOutLineElectricEqpmt(map<string,BaseElectricEqpmt*>& eqpmtmap, int nMark /*= 0*/)
 {

 }

 bool BaseElectricEqpmt::BoltPowerIn_35KV( map<string,BaseElectricEqpmt*>& eqpmtmap, const string& strOutLineElectricEqpmtStrID )
 {
	return true;
 }

 void BaseElectricEqpmt::PowerCutCurElectricEqpmt_400V( ELEEQPMTMAP& ElectricEqpmtMap )
 {

 }

 void BaseElectricEqpmt::SetElcEqpmtAlarmInfoMap( ELCEQPMTALARMINFOMAP* m_AlarmInfoMap )
 {
	 	m_EqpmtAlarmInfoMap = m_AlarmInfoMap;
 }

 void BaseElectricEqpmt::UpdateAlarmInfo( string EppmtTypeName,string EqpmtName,int SourceStaionID,ELCEQPMTALARMINFO& EqpmtAlarmInfo )
 {
	 string AlarmText = EqpmtAlarmInfo.m_strAlrmText;                    //报文内容
	 int     AlarmSytem = EqpmtAlarmInfo.m_nAlarmSystem;                  //报文所属系统:Elc_AlarmRegion_PSCADA-10
	 int     AlarmLevel = EqpmtAlarmInfo.m_nAlarmLevel;                   //报文等级
	 int     AlarmType = EqpmtAlarmInfo.m_nAlarmType;                     //报文类型：报警DH_MSGCATEGORY_PSCADA-9，日志DH_MSGCATEGORY_SOE-2等
	 int     IsFault = EqpmtAlarmInfo.m_nIsFault;                     //是否为故障触发报文：故障1、常规操作0

	 string strtext;
	 std::stringstream ss;
	 ss << EppmtTypeName << " " << EqpmtName << " " << AlarmText;
	 strtext = ss.str();
	 SendMsgNotice(SourceStaionID, AlarmSytem, AlarmLevel, AlarmType, IsFault, strtext,GetEqpmentID());//modified by zhangjiahua
 }

 void BaseElectricEqpmt::UpdateAlarmType( int EppmtType,string EppmtTypeName,string EqpmtName,int SourceStaionID ,int ActType)
 {
	 string strEqpmtTypeName = EppmtTypeName;            //设备类型名称
	 string strEqpmtName = EqpmtName;                    //设备名称
	 int     nEqpmtSourceStatonID = SourceStaionID;       //设备所属车站ID
	 int     nEqpmtType = EppmtType;                      //设备类型
	 int     nActType = ActType;                          //动作类型
	 ELCEQPMTALARMINFOMAP::iterator iterAlarmEqpmtType = m_EqpmtAlarmInfoMap->find(nEqpmtType);
	 if (iterAlarmEqpmtType!=m_EqpmtAlarmInfoMap->end())
	 {
		 ELCEQPMTALARMACTTYPEMAP mapAlarmActType = iterAlarmEqpmtType->second;
		 ELCEQPMTALARMACTTYPEMAP::iterator iterAlarmActType=mapAlarmActType.begin();
		 for (;iterAlarmActType!=mapAlarmActType.end();iterAlarmActType++)
		 {
			 if (ActType==iterAlarmActType->first)
			 {
				UpdateAlarmInfo(strEqpmtTypeName,strEqpmtName,nEqpmtSourceStatonID,iterAlarmActType->second); 
			 }
		 }
	 }
 }


 void BaseElectricEqpmt::UpdateOperResultToTechEva( string strEqpmtID,int nResultStatus )
 {
	 UpdateEvaOperStatus pUpdateOperTemp;
	 pUpdateOperTemp.TrainID = m_Trianid;  //训练号
	 pUpdateOperTemp.OperItemType = Item_Type_DD;     //条目类型：2-电调
	 strncpy(pUpdateOperTemp.AssociPara1, strEqpmtID.c_str(), sizeof(pUpdateOperTemp.AssociPara1));  //关联参数1：设备ID
	 pUpdateOperTemp.OperStatus = nResultStatus;                  //操作状态：设备操作结果状态
	 pUpdateOperTemp.OperItemObject = MajorType_DD;               //条目对应评价对象-电调
	 pUpdateOperTemp.OperStuID = MajorType_DD;                    //操作对象类型-电调
     pUpdateOperTemp.OperItemSubType1 = 1;							//开关设备操作
     if (nResultStatus == 1)
     {
         pUpdateOperTemp.OperItemSubType2 = 2;                    //合闸
     }
     else if (nResultStatus == 0)
     {
         pUpdateOperTemp.OperItemSubType2 = 1;                    //分闸
     }
	 OCCCOMMAND NetOrderToTech;            
	 NetOrderToTech.DesSysType = OCC_SYS_SERVER_TH;
	 NetOrderToTech.ScrSysType = OCC_SYS_DD_SVR;
	 NetOrderToTech.TrainningID = m_Trianid;
	 NetOrderToTech.setPacketValue(&pUpdateOperTemp,OCCCOMMAND::eUpdateEvaOperStatus);
	 p_SendList->push(NetOrderToTech);
 }

 void BaseElectricEqpmt::UpdateEqpmtLightCardStatu(int nProtectID)
 {
	 DHEQPMTUPDATE updatadata;
	 updatadata.CtrlLock=GetControlLock();
	 updatadata.FaultLock=GetFaultLockStatus();
	 updatadata.RemoteLock=GetRemoteLockStatus();
	 updatadata.CommunicationStaus=GetCommunicationStatus();
	 updatadata.CtrlArea=GetControlArea();

	 updatadata.CtrlType = CTRLTYPE_UpLightCard;
	 updatadata.Status= nProtectID;

	 updatadata.Category = GetBaseType();
	 updatadata.SubSys = ISCS_SUBSYS_TYPE_ELC;
	 string strID=GetEqpmentID();

	 strncpy(updatadata.EqpmtStrID,strID.c_str(), sizeof(updatadata.EqpmtStrID));
	 string strName=GetEqpmentName();
	 strncpy(updatadata.EqpmtName,strName.c_str(), sizeof(updatadata.EqpmtName));
	 updatadata.StationID = GetStationID();
	 updatadata.ViewID = GetViewID();
	 OCCCOMMAND tmpSendHC;
	 tmpSendHC.setPacketValue(&updatadata,OCCCOMMAND::eUpdateEqpmtStatus);
	 tmpSendHC.DesSysType=OCC_SYS_DD_CLIENT;
	 tmpSendHC.TrainningID = m_Trianid;
	 tmpSendHC.ScrSysType=OCC_SYS_DD_SVR;
	 p_SendList->push(tmpSendHC);
 }

 void BaseElectricEqpmt::SendExamModeEqpmtCheckStatus(int stdid,int subsysyid,int trianid,int stationid,int viewid)
 {
	 DHSVRREPLY CheckReplyMsg;
	 memset(CheckReplyMsg.ReplyText,0,ALARM_LEN) ;
	 string retstr = "";
	 int retstatus = DH_CmdReplyStatus_Pass;
	 strncpy(CheckReplyMsg.ReplyText,retstr.c_str(), sizeof(CheckReplyMsg.ReplyText));
	 CheckReplyMsg.CmdID = OCCCOMMAND::eUpdateOperCheck;
	 string strID=GetEqpmentID();
	 strncpy(CheckReplyMsg.EqpmtStrID,strID.c_str(), sizeof(CheckReplyMsg.EqpmtStrID));
	 CheckReplyMsg.AutoBoltStatus=1;
	 CheckReplyMsg.CtrlLock= GetFaultLockStatus() /*GetControlLock()*/;
	 CheckReplyMsg.StdID = stdid;
	 CheckReplyMsg.EqpmtStatus =retstatus;  //100表示通过，101拒绝
	 CheckReplyMsg.StationID=stationid;
	 CheckReplyMsg.ViewID = viewid;
	 CheckReplyMsg.SubSysID = subsysyid;
	 OCCCOMMAND NetOrder;
	 NetOrder.DesSysType = OCC_SYS_DD_CLIENT;
	 NetOrder.ScrSysType = OCC_SYS_DD_SVR;
	 NetOrder.TrainningID = trianid;
	 NetOrder.setPacketValue(&CheckReplyMsg,OCCCOMMAND::eUpdateSvrReply);
	 p_SendList->push(NetOrder);
 }

 void BaseElectricEqpmt::UpdateEqpmtTeleValue( string strEqpmtID, int nType, float fValue, int IsReset)
 {
	 EQPMTTELEMTRYVALUE SetEqpmtTeleValue;
	 strncpy(SetEqpmtTeleValue.EqpmtStrID, strEqpmtID.c_str(), sizeof(SetEqpmtTeleValue.EqpmtStrID));
	 SetEqpmtTeleValue.nType = nType;
	 SetEqpmtTeleValue.fValue = fValue;
	 SetEqpmtTeleValue.IsReset = IsReset;

	 OCCCOMMAND NetOrder;
	 NetOrder.DesSysType = OCC_SYS_DD_CLIENT;
	 NetOrder.ScrSysType = OCC_SYS_DD_SVR;
	 NetOrder.TrainningID = m_Trianid;
	 NetOrder.setPacketValue(&SetEqpmtTeleValue,OCCCOMMAND::eUpdateEqpmtTelemeteryValue);
	 p_SendList->push(NetOrder);
 }

 //更新设备带电状态
 void BaseElectricEqpmt::UpdateEqpmtPower( string strEqpmtID, int power)
 {
	 if (p_SendList!=nullptr)
	 {
		 EQPMTPOWERSTATUS SetEqpmtPower;
		 strncpy(SetEqpmtPower.EqpmtStrID, strEqpmtID.c_str(), sizeof(SetEqpmtPower.EqpmtStrID));
		 SetEqpmtPower.nPower = power;

		 OCCCOMMAND NetOrder;
		 NetOrder.DesSysType = OCC_SYS_DD_CLIENT;
		 NetOrder.ScrSysType = OCC_SYS_DD_SVR;
		 NetOrder.TrainningID = m_Trianid;
		 NetOrder.setPacketValue(&SetEqpmtPower,OCCCOMMAND::eUpdateEqpmtPowerStatus);
		 p_SendList->push(NetOrder);
	 }
 }