mx.cpp

电力系统无功自动补偿的操作系统程序

		for (i=0;i<linkMXNum;i++){
			if (linkMX[i]->currUseDkqOnNum!=linkMX[i]->DKQNum){
				temp[j] = linkMX[i];
				j++;
			}
		}
		if (j==0) return NULL; //未找到

		//将母线按已合上电抗器数,由少到多排列
		for (i=0;i<j-1;i++)
		for (k=i+1;k<j;k++)
			if (temp[i]->currUseDkqOnNum > temp[k]->currUseDkqOnNum){
				tm = temp[k];
				temp[k] = temp[i];
				temp[i] = tm;
			}

		//找出用来合的电抗器
		pq = NULL;
		onCloseNum = temp[0]->currUseDkqOnNum;

		for (i=0;i<j;i++){
			if (onCloseNum != temp[i]->currUseDkqOnNum) {
				if (pq!=NULL)  break; //已找到电抗器，母线上电抗器合数目不同,则结束
				else onCloseNum = temp[i]->currUseDkqOnNum;
			}

			findDev = temp[i]->FindDkqForCloseOnOneMxProc();
			if (!findDev) continue;
			if (!pq)  pq= findDev;
			else if (pq->lastActTime > findDev->lastActTime)
		  		pq = findDev;
		  }
		return pq;
	}

	//将母线按已合上电容器数,由多到少排列
	for (i=0;i<j-1;i++)
	for (k=i+1;k<j;k++)
		if (temp[i]->currUseDrqOnNum < temp[k]->currUseDrqOnNum){
			tm = temp[k];
			temp[k] = temp[i];
			temp[i] = tm;
		}
	pq = NULL;
	//按优先级别,找出可以切的电容器
	onCloseNum = temp[0]->currUseDrqOnNum;
	for (i=0;i<j;i++){
		if (onCloseNum != temp[i]->currUseDrqOnNum) {
			if (pq!=NULL)  break;//已找到电容器，母线上电容器合数目不同,则结束
			else onCloseNum = temp[i]->currUseDrqOnNum;
		}
	    findDev = temp[i]->FindDrqForOpenOnOneMxProc();
		if (!findDev) continue;
		if (!pq)  pq= findDev;
		else if (pq->lastActTime > findDev->lastActTime)
			pq = findDev;
  	}
	return pq;
}

VQCDRQ_DBS * VQCMUXI_DBS::FindDkgOpenOrDrqClose()   //currUseDevForReduceQRiseU
{
	BYTE i,j,k;
	VQCMUXI_DBS * temp[VQC_ZBNUM*2];
	VQCMUXI_DBS * tm;
	VQCDRQ_DBS  * pq = NULL;
	VQCDRQ_DBS  * findDev ;
	BYTE onCloseNum;

	//找出有合上电抗器的母线
	j = 0;
	for (i=0;i<linkMXNum;i++){
		if (linkMX[i]->currUseDkqOnNum){
			temp[j] = linkMX[i];
			j++;
		}
	}
	if (j==0){//未找到
		//找出有电容器可以合的母线
		j = 0;
		for (i=0;i<linkMXNum;i++){
			if (linkMX[i]->currUseDrqOnNum!=linkMX[i]->DRQNum){
				temp[j] = linkMX[i];
				j++;
			}
		}
		if (j==0) return NULL;//未找到
		//将母线按已合上电容器数,由少到多排列
		for (i=0;i<j-1;i++)
		for (k=i+1;k<j;k++)
			if (temp[i]->currUseDrqOnNum > temp[k]->currUseDrqOnNum){
				tm = temp[k];
				temp[k] = temp[i];
				temp[i] = tm;
			}

		pq = NULL;
		//按优先级别,找出用来合的电容器
		onCloseNum = temp[0]->currUseDrqOnNum;
		for (i=0;i<j;i++){
			if (onCloseNum != temp[i]->currUseDrqOnNum) {
				if (pq!=NULL)  break;//已找到电容器，母线上电容器合数目不同,则结束
				else onCloseNum = temp[i]->currUseDrqOnNum;
			}

			findDev = temp[i]->FindDrqForCloseOnOneMxProc();
			if (!findDev) continue;
			if (!pq) pq = findDev;
			else if (pq->lastActTime > findDev->lastActTime)
				pq = findDev;
		}
		return pq;
	}

	//将母线按已合上电抗器数,由多到少排列
	for (i=0;i<j-1;i++)
	for (k=i+1;k<j;k++)
		if (temp[i]->currUseDkqOnNum < temp[k]->currUseDkqOnNum){
			tm = temp[k];
			temp[k] = temp[i];
			temp[i] = tm;
		}

	//找出可以切的电抗器
	pq = NULL;
	onCloseNum = temp[0]->currUseDkqOnNum;
	for (i=0;i<j;i++){
		if (onCloseNum != temp[i]->currUseDkqOnNum){
			if (pq!=NULL) break;//已找到电抗器，母线上电抗器合数目不同,则结束
			else onCloseNum = temp[i]->currUseDkqOnNum;
		}

		findDev = temp[i]->FindDkqForOpenOnOneMxProc();
		if (!findDev) continue;
		if (!pq)  pq = findDev;
		else if (pq->lastActTime > findDev->lastActTime)
 	  		pq = findDev;
  	}
	return pq;
}

BYTE VQCMUXI_DBS::GetIntegrateZoneWithQUZone(BYTE UZone, BYTE QZone)
{
    if ((UZone==ZONE_UP_LOCK)||(UZone==ZONE_DOWN_LOCK)) return RUN_ZONE_LOCK;
	if ((QZone==ZONE_UP_LOCK)||(QZone==ZONE_DOWN_LOCK)) return RUN_ZONE_LOCK;
    switch(UZone){
		case ZONE_UP:
			if (QZone==ZONE_NORMAL) return RUN_ZONE_UP;
			else if ((QZone==ZONE_NORMAL_DOWN)||(QZone==ZONE_DOWN)) return RUN_ZONE_LEFT_UP;
			else return RUN_ZONE_RIGHT_UP;
		case ZONE_NORMAL_UP:
			if (QZone==ZONE_DOWN) return RUN_ZONE_LEFT_UP;
			else if (QZone==ZONE_UP) return RUN_ZONE_RIGHT_UP;
			else return RUN_ZONE_NORMAL;
		case ZONE_NORMAL:
			if (QZone==ZONE_DOWN) return RUN_ZONE_LEFT;
			if (QZone==ZONE_UP)   return RUN_ZONE_RIGHT;
			return RUN_ZONE_NORMAL;
		case ZONE_NORMAL_DOWN:
			if (QZone==ZONE_DOWN) return RUN_ZONE_LEFT_DOWN;
			else if (QZone==ZONE_UP) return RUN_ZONE_RIGHT_DOWN;
			else return RUN_ZONE_NORMAL;
		case ZONE_DOWN:
			if (QZone==ZONE_NORMAL) return RUN_ZONE_DOWN;
			else if ((QZone==ZONE_NORMAL_DOWN)||(QZone==ZONE_DOWN)) return RUN_ZONE_LEFT_DOWN;
			else return RUN_ZONE_RIGHT_DOWN;
	};
	return RUN_ZONE_LOCK;
}

BYTE VQCMUXI_DBS::GetIntegrateZoneWithQUValue(float UValue, float QValue,float dUpU,float dDownU,float dUpQ,float dDownQ)
{
BYTE UZone;
BYTE QZone;

	if (UValue >= U.LockUpLimit) UZone = ZONE_UP_LOCK;
	else if (UValue <= U.LockDownLimit)	UZone = ZONE_DOWN_LOCK;
	else if (UValue >= U.currUpLimit)	UZone = ZONE_UP;
	else if (UValue <= U.currDownLimit)	UZone = ZONE_DOWN;
	else if (UValue > (U.currUpLimit-dUpU))	UZone = ZONE_NORMAL_UP;
	else if (UValue < (U.currDownLimit+dDownU))	UZone = ZONE_NORMAL_DOWN;
	else UZone = ZONE_NORMAL;

	if (QValue >= Q.LockUpLimit) QZone = ZONE_UP_LOCK;
	else if (QValue <= Q.LockDownLimit)	QZone = ZONE_DOWN_LOCK;
	else if (QValue >= Q.currUpLimit)	QZone = ZONE_UP;
	else if (QValue <= Q.currDownLimit)	QZone = ZONE_DOWN;
	else if (QValue > (Q.currUpLimit-dUpQ)){
		if (QValue < (Q.currDownLimit+dDownQ))	QZone = ZONE_NORMAL_DOWN;//范围重叠，说明负载轻，只能把无功视作偏小
		else QZone = ZONE_NORMAL_UP;
	}
	else if (QValue < (Q.currDownLimit+dDownQ))	QZone = ZONE_NORMAL_DOWN;
	else QZone = ZONE_NORMAL;

	return (GetIntegrateZoneWithQUZone(UZone, QZone));
}

void VQCMUXI_DBS::AdjustWeightProc(BYTE zone, UINT askFjtActWeight, UINT askDrqActWeight)
{

    switch(zone){

	    case RUN_ZONE_LEFT_UP:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_Q:
				case VQCMODE_FIRST_Q:
				case VQCMODE_ALL:
					askDrqOpenWeight += askDrqActWeight;
					break;
				case VQCMODE_FIRST_U:
					askDrqOpenWeight += askDrqActWeight;
					if (U.zone == ZONE_UP)
					askFjtDownWeight += askFjtActWeight;
					firstDrqNum ++;
					break;
				case VQCMODE_ONLY_U:
					askFjtDownWeight += askFjtActWeight;
					break;
			    default:
					break;
		    };
			return;

	    case RUN_ZONE_RIGHT_DOWN:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_Q:
				case VQCMODE_ALL:
				case VQCMODE_FIRST_Q:
					askDrqCloseWeight += askDrqActWeight;
					break;
				case VQCMODE_FIRST_U:
					askDrqCloseWeight += askDrqActWeight;
					if (U.zone == ZONE_DOWN)
					askFjtUpWeight    += askFjtActWeight;
					firstDrqNum ++;
					break;
				case VQCMODE_ONLY_U:
					askFjtUpWeight += askFjtActWeight;
					break;
			};
			return;
    
		case RUN_ZONE_RIGHT_UP:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_U:
				case VQCMODE_ALL:
					askFjtDownWeight += askFjtActWeight;
					break;
				case VQCMODE_FIRST_U:
					askFjtDownWeight += askFjtActWeight;
					if (U.zone == ZONE_UP)
					askDrqOpenWeight += askDrqActWeight;
					firstFjtNum ++;
					break;
				case VQCMODE_FIRST_Q:
					askFjtDownWeight += askFjtActWeight;
					if (Q.zone == ZONE_UP)
					askDrqCloseWeight+= askDrqActWeight;
					firstFjtNum ++;
					break;
				case VQCMODE_ONLY_Q:
					askDrqCloseWeight += askDrqActWeight;
					break;
			};
			return;
		case RUN_ZONE_LEFT_DOWN:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_U:
				case VQCMODE_ALL:
					askFjtUpWeight += askFjtActWeight;
					break;
				case VQCMODE_FIRST_U:
					askFjtUpWeight   += askFjtActWeight;
					if (U.zone == ZONE_DOWN)
					askDrqCloseWeight+= askDrqActWeight;
					firstFjtNum ++;
					break;
				case VQCMODE_FIRST_Q:
					askFjtUpWeight   += askFjtActWeight;
					if (Q.zone == ZONE_DOWN)
					askDrqOpenWeight += askDrqActWeight;
					firstFjtNum ++;
					break;
				case VQCMODE_ONLY_Q:
					askDrqOpenWeight += askDrqActWeight;
					break;
			};
			return;

		case RUN_ZONE_UP:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_Q:
					askDrqOpenWeight += askDrqActWeight;
					break;
				case VQCMODE_ONLY_U:
					askFjtDownWeight += askFjtActWeight;
					break;
			    case VQCMODE_FIRST_Q:
			    case VQCMODE_FIRST_U:
				case VQCMODE_ALL:
					askFjtDownWeight   += askFjtActWeight;
					askDrqOpenWeight   += askDrqActWeight;
					if (pGlobalDef->bFirstDrq) firstDrqNum ++;
					else    firstFjtNum ++;
					break;
			};
			return;
    
		case RUN_ZONE_DOWN:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_Q:
					askDrqCloseWeight += askDrqActWeight;
					break;
				case VQCMODE_ONLY_U:
					askFjtUpWeight    += askFjtActWeight;
					break;
				case VQCMODE_FIRST_Q:
				case VQCMODE_FIRST_U:
				case VQCMODE_ALL:
					askFjtUpWeight    += askFjtActWeight;
					askDrqCloseWeight += askDrqActWeight;
					if (pGlobalDef->bFirstDrq) firstDrqNum ++;
					else firstFjtNum ++;
				break;
			};
			return;
    
		case RUN_ZONE_LEFT:
			switch(pGlobalDef->RunMode){
				case VQCMODE_ONLY_Q:
				case VQCMODE_FIRST_U:
					askDrqOpenWeight += askDrqActWeight;
					break;
				case VQCMODE_ONLY_U:
					break;
				case VQCMODE_FIRST_Q:
				case VQCMODE_ALL:
					if ((pFatherZB->DQ >0.00001f)||(pFatherZB->DQ <-0.00001f)) askFjtUpWeight   += askFjtActWeight;
					askDrqOpenWeight += askDrqActWeight;
					firstDrqNum ++;
				break;
			};
			return;

		case RUN_ZONE_RIGHT:
		    switch(pGlobalDef->RunMode){
			    case VQCMODE_ONLY_Q:
				case VQCMODE_FIRST_U:
					askDrqCloseWeight += askDrqActWeight;
					break;
				case VQCMODE_ONLY_U:
					break;
				case VQCMODE_FIRST_Q:
				case VQCMODE_ALL:
					if ((pFatherZB->DQ >0.00001f)||(pFatherZB->DQ <-0.00001f)) askFjtDownWeight   += askFjtActWeight;
					askDrqCloseWeight += askDrqActWeight;
					firstDrqNum ++;
					break;
			};
			return;
	}
    return;
}

BOOL VQCMUXI_DBS::ActFjtForOneZB(VQCZB_DBS *pZB, BOOL bFjtUp)
{

	if (lockReasonStatus & 0x3fff)			return FALSE;
	if (pZB->fjtLockReasonStatus & 0x3fff)  return FALSE;

	if (bFjtUp){
		if (lockReasonStatus & LOCK_MX_FORBIDUPU)	return FALSE;
		if (pZB->fjtLockReasonStatus & LOCK_FJT_UP) return FALSE;
	}
	else{
		if (lockReasonStatus & LOCK_MX_FORBIDDOWNU)	  return FALSE;
		if (pZB->fjtLockReasonStatus & LOCK_FJT_DOWN) return FALSE;
	}

    if (!pGlobalDef->bWatch)
        if (FALSE == pZB->FjtYtSJRec.DoYtProc(bFjtUp))  return FALSE;

    if (!pGlobalDef->bWatch){  //结果检查设置
        pZB->bIsFjt        = TRUE;
	    pZB->ptrCheckDRDKQ = NULL;
        pZB->bResultReturn = FALSE;
        pZB->bYkClose      = bFjtUp;
		pZB->reActTimes    = 0;
		soe.isFjt	= TRUE;
		soe.operType = bFjtUp;
		//soe.ykNo = useDev->GetYkNo();
		pZB->FjtYtSJRec.GetName(soe.operDevName);
		soe.zbNo = ZBNo+1;
		soe.mxNo = MXNo+1;
		soe.zbDw = pZB->oldFjtYtDw;
		soe.U = U.sampleValue[0];
		soe.uMeanValue	= U.meanValue;
		soe.uUpLimit	= U.currUpLimit;
		soe.uDownLimit	= U.currDownLimit;
		if (pGlobalDef->bUseCos){
			soe.Q			= Q.cosq_realValue;
			soe.qMeanValue	= 0.0f;
			soe.qUpLimit	= Q.cosq_currUpLimit;
			soe.qDownLimit	= Q.cosq_currDownLimit;
		}
		else{
			soe.Q = Q.sampleValue[0];
			soe.qMeanValue	= Q.meanValue;
			soe.qUpLimit	= Q.currUpLimit;
			soe.qDownLimit	= Q.currDownLimit;
		}
		soe.HappenTime	= pGlobalDef->currTime;
		soe.SaveVQCSoeProc(pFatherZB->pFatherVQC->ownerRtuNo);
	}
	else {
        pZB->bResultReturn = TRUE;
		if (bFjtUp)	AskFjtUpRec.SetWfStatus(TRUE);
		else		AskFjtDownRec.SetWfStatus(TRUE);
	}

    pZB->adjustNeedLockTime= pGlobalDef->NextActTime;
    pZB->reActTimes = 0;
    pZB->pFatherVQC->actDayTimes ++;
    pZB->pFatherVQC->actTotalTimes ++;

    pZB->fjtActDayTimes ++;
    pZB->fjtActTotalTimes ++;
    pZB->adjustNeedLockTime= pGlobalDef->NextActTime;
    pZB->fjtActNeedLockTime = pZB->FJTLockTime;
	pZB->lockReasonStatus |= LOCK_FJT_NOTREADY;
	return TRUE;
}

BOOL VQCMUXI_DBS::DoFjtActProc(BOOL bFjtUp, BOOL bakMode, BOOL bDrqClose)
{
	BOOL bCanDo;
	BYTE i;
	int dw, num;
	VQCZB_DBS *tempZB[VQC_ZBNUM];

    if (lockReasonStatus & LOCK_MX_ACTING) return FALSE;

	//找出所有主变分接头档位最高或最低档位进行降或升操作
	pFatherZB->linkZB[0]->actDwValue = (int)(pFatherZB->linkZB[0]->YtDwValueRec.GetYtValue()+0.5);
	dw = pFatherZB->linkZB[0]->actDwValue;
	num =1;
	tempZB[0] = pFatherZB->linkZB[0];

	for (i=1;i<pFatherZB->linkZBNum;i++){
		pFatherZB->linkZB[i]->actDwValue = (int)(pFatherZB->linkZB[i]->YtDwValueRec.GetYtValue()+0.5);
		if (dw == pFatherZB->linkZB[i]->actDwValue) {
			tempZB[num] = pFatherZB->linkZB[i];
			num ++;
		}
		else {