mx.cpp

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

			if (bFjtUp){
				if (dw > pFatherZB->linkZB[i]->actDwValue) {
					dw = pFatherZB->linkZB[i]->actDwValue;
					num =1;
					tempZB[0] = pFatherZB->linkZB[i];
				}
			}
			else {
				if (dw < pFatherZB->linkZB[i]->actDwValue) {
					dw = pFatherZB->linkZB[i]->actDwValue;
					num =1;
					tempZB[0] = pFatherZB->linkZB[i];
				}
			}
		}
	}

	bCanDo = FALSE;
	for (i=0;i<num;i++)	
		if (ActFjtForOneZB(tempZB[i], bFjtUp))	bCanDo = TRUE;

	if (!bCanDo)
		if (bakMode) return(DoDrqActProc(bDrqClose, FALSE, 0));
		else return FALSE;


	//设置闭锁状态
    for (i=0;i<linkMXNum;i++) linkMX[i]->lockReasonStatus |= LOCK_MX_ACTING;
    for (i=0;i<pFatherZB->linkZBNum;i++) pFatherZB->linkZB[i]->lockReasonStatus |= LOCK_ZB_ACTING;

    return TRUE;
}

BOOL VQCMUXI_DBS::DoDrqActProc(BOOL bDrqClose, BOOL bakMode, BOOL bFjtUp)
{
	VQCDRQ_DBS * useDev;
	BOOL bClose,bCanDo;
	BYTE i;

    if (lockReasonStatus & LOCK_MX_ACTING) return FALSE;
	
	bCanDo = TRUE;
	if (bDrqClose){
		useDev = currUseDevForReduceQRiseU;
		if (lockReasonStatus & LOCK_MX_FORBIDUPU) bCanDo = FALSE;
	}
	else {
		useDev = currUseDevForRiseQReduceU;
		if (lockReasonStatus & LOCK_MX_FORBIDDOWNU) bCanDo = FALSE;
	}
	if (useDev == NULL) bCanDo = FALSE;
	if (!bCanDo)
		if (bakMode) return(DoFjtActProc(bFjtUp, FALSE, 0));
		else return FALSE;

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

	bClose = bDrqClose;
	if (!useDev->IsDrq) bClose = !bClose;   //电抗器与电容器动作相反

    if (!pGlobalDef->bWatch)
        if (FALSE ==useDev->KgRec.DoYkProc(bClose))  return FALSE;

    useDev->lastActTime = pGlobalDef->runTime;

    for (i=0;i<linkMXNum;i++) linkMX[i]->lockReasonStatus |= LOCK_MX_ACTING;
    for (i=0;i<pFatherZB->linkZBNum;i++) pFatherZB->linkZB[i]->lockReasonStatus |= LOCK_ZB_ACTING;

    if (!pGlobalDef->bWatch){  //结果检查设置
        pFatherZB->bIsFjt        = FALSE;
	    pFatherZB->ptrCheckDRDKQ = useDev;
        pFatherZB->bResultReturn = FALSE;
        pFatherZB->bYkClose      = bClose;
		pFatherZB->reActTimes    = 0;
		soe.isFjt	= FALSE;
		soe.operType = bClose;
		//soe.ykNo = useDev->GetYkNo();
		useDev->KgRec.GetName(soe.operDevName);
		soe.zbNo = ZBNo+1;
		soe.mxNo = MXNo+1;
		soe.zbDw = pFatherZB->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 {
        pFatherZB->bResultReturn = TRUE;
		if (bDrqClose)  AskDrqCloseRec.SetWfStatus(TRUE);
		else			AskDrqOpenRec.SetWfStatus(TRUE);
	}

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

    useDev->actDayTimes ++;
    useDev->actTotalTimes ++;
    useDev->kgNeedLockTime =0;
    useDev->lastActTime = pGlobalDef->runTime;
	useDev->kgNeedLockTime = useDev->LockTime;
	useDev->lockReasonStatus |= LOCK_DRQ_NOTREADY;

    return TRUE;
}

void VQCMUXI_DBS::AdjustMXVQCProc()
{
BOOL bFjtUp;
BOOL bDrqClose;
BOOL bFjtAct;
BOOL bDrqAct;

    bDrqAct =FALSE;
    if (askDrqOpenWeight  >= ActWeight){
		if (!pGlobalDef->bWatch)  AskDrqOpenRec.SetWfStatus(TRUE);
		AskDrqCloseRec.SetWfStatus(FALSE);
		if (lockReasonStatus & LOCK_MX_FORBIDDOWNU)	bDrqAct = FALSE;
		else {
			bDrqAct   = TRUE;      //可以动电容器(或电抗器)
			bDrqClose = FALSE;
		}
	}
	else if (askDrqCloseWeight >= ActWeight){
		AskDrqOpenRec.SetWfStatus(FALSE);
		if (!pGlobalDef->bWatch)  AskDrqCloseRec.SetWfStatus(TRUE);
		if (lockReasonStatus & LOCK_MX_FORBIDUPU) bDrqAct = FALSE;
		else{			
			bDrqAct   = TRUE;  //可以动电容器(或电抗器)
			bDrqClose = TRUE;
		}
	}
	else if (sampleNum>2){
		if (askDrqCloseWeight<=0) AskDrqCloseRec.SetWfStatus(FALSE);
		if (askDrqOpenWeight<=0)  AskDrqOpenRec.SetWfStatus(FALSE);
	}

    bFjtAct = FALSE;
    if (askFjtDownWeight    >= ActWeight){
		AskFjtUpRec.SetWfStatus(FALSE);
		if (!pGlobalDef->bWatch)  AskFjtDownRec.SetWfStatus(TRUE);
	    bFjtAct =TRUE;
		if (lockReasonStatus & LOCK_MX_FORBIDDOWNU)	bFjtAct = FALSE;
		bFjtUp = FALSE;
	}
    else if (askFjtUpWeight >= ActWeight){
		AskFjtDownRec.SetWfStatus(FALSE);
		if (!pGlobalDef->bWatch)  AskFjtUpRec.SetWfStatus(TRUE);
	    bFjtAct =TRUE;
		if (lockReasonStatus & LOCK_MX_FORBIDUPU)	bFjtAct = FALSE;
		bFjtUp = TRUE;
	}
	else if (sampleNum>2){
		if (askFjtUpWeight<=0)   AskFjtUpRec.SetWfStatus(FALSE);
		if (askFjtDownWeight<=0) AskFjtDownRec.SetWfStatus(FALSE);
	}

    if ((bFjtAct==FALSE)&&(bDrqAct==FALSE)) return;

    if (pGlobalDef->bWatch) return;

    if (bFjtAct&&bDrqAct) {
	    if (firstFjtNum < firstDrqNum)
		      DoDrqActProc(bDrqClose,TRUE,bFjtUp);
	    else  DoFjtActProc(bFjtUp,TRUE,bDrqClose);
    }
    else {
	    if (bFjtAct)      DoFjtActProc(bFjtUp,FALSE,0);
		else if (bDrqAct) DoDrqActProc(bDrqClose,FALSE,0);
    }
}

void VQCMUXI_DBS::ResetUQZone(float dUpU, float dDownU,float dUpQ, float dDownQ)
{
	if (U.realValue >= U.LockUpLimit)			U.zone = ZONE_UP_LOCK;
	else if (U.realValue <= U.LockDownLimit)	U.zone = ZONE_DOWN_LOCK;
	else if (U.realValue >= U.currUpLimit)		U.zone = ZONE_UP;
	else if (U.realValue <= U.currDownLimit)	U.zone = ZONE_DOWN;
	else if (U.realValue > (U.currUpLimit-dUpU))	U.zone = ZONE_NORMAL_UP;
	else if (U.realValue < (U.currDownLimit+dDownU))	U.zone = ZONE_NORMAL_DOWN;
	else U.zone = ZONE_NORMAL;

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

BOOL VQCMUXI_DBS::CheckDrqUsedWillReciprocate(float uValue, float qValue, VQCDRQ_DBS *useDev)
{
	float dQ,dU;

		if (useDev !=NULL){
			 dQ = useDev->DQ;
			 dU = useDev->DU;
		}
		else {
			if (pGlobalDef->bWatch){
		        askDrqOpenWeight  = 0;
			    askDrqCloseWeight = 0;
				firstDrqNum       = 0;
			}
			return TRUE;
		}

		//电容器投切,处于振荡范围
        if ((askDrqCloseWeight)&&(qValue>Q.currUpLimit))  {   //无功越上限
			qValue -= dQ;
			//电容器处于振荡范围，正常情况，不能投电容器.
			//若考虑到电压,则电压越下限时要投电容器
			if (qValue < Q.currDownLimit){   //处于振荡范围
		        if (uValue>=U.currDownLimit){   //电压未越下限,不能合
			        askDrqOpenWeight  = 0;
				    askDrqCloseWeight = 0;
					firstDrqNum       = 0;
					return TRUE;
		        }
				else if ((pGlobalDef->RunMode != VQCMODE_FIRST_U)
					&&(pGlobalDef->RunMode != VQCMODE_ONLY_U)
					&&(pGlobalDef->RunMode != VQCMODE_ALL)){
			        askDrqOpenWeight  = 0;
				    askDrqCloseWeight = 0;
					firstDrqNum       = 0;
					return TRUE;
				};
			}
	    }
			//电容器处于振荡范围，正常情况退电容器，
			//若考虑到电压,则电压正常偏底时要不能退电容器
		else   
        if ((askDrqOpenWeight)&&(qValue<Q.currDownLimit)){       //无功越下限
		    qValue += dQ;
			if (qValue > Q.currUpLimit)      //处于振荡范围
			if (uValue<=(U.currDownLimit+dU)){   //电压偏低,不能退电容器
				askDrqCloseWeight =0;
			    askDrqOpenWeight  =0;
	            firstDrqNum  =0;
				return TRUE;
		    }
		}
	return FALSE;
}

void VQCMUXI_DBS::DoAdjustProc()
{
	UINT  askDrqActWeight,askFjtActWeight;
	float tf;
	int i, zone;
	VQCDRQ_DBS *useDev;
	float dUpU,dDownU;
	float dUpQ,dDownQ;

	UINT lockMask;
	lockMask  = LOCK_MX_TIMES_OVER;
	lockMask |= LOCK_MX_BH;
	lockMask |= LOCK_MX_YC;
	lockMask |= LOCK_MX_YX;
	lockMask |= LOCK_MX_STOP;
	lockMask |= LOCK_MX_NOTRUN;
	lockMask |= LOCK_MX_NOTLINK;
	lockMask |= LOCK_MX_ACTING;
	lockMask |= LOCK_MX_VALUE_OVER;

	askFjtUpWeight   = 0;
	askFjtDownWeight = 0;
	askDrqCloseWeight= 0;
	askDrqOpenWeight = 0;
	firstFjtNum		 = 0;
	firstDrqNum		 = 0;

	//防止 Q.realValue 值因母线并列被修改
	Q.sampleValue[0] = Q.realValue;    

	//计算平均值
	U.meanValue = 0.0;
	Q.meanValue = 0.0;
	for (i=0;i<(int)sampleNum;i++){
		U.meanValue += U.sampleValue[i];
		Q.meanValue += Q.sampleValue[i];
	}
	U.meanValue /= sampleNum;
	Q.meanValue /= sampleNum;

	U.SetZoneProc();
	Q.SetZoneProc();

	currUseDevForRiseQReduceU = FindDrqOpenOrDkgClose();
	currUseDevForReduceQRiseU = FindDkgOpenOrDrqClose();

	useDev = NULL;
	switch(U.zone){
	case ZONE_UP :
		useDev = currUseDevForRiseQReduceU;
		if (Q.zone == ZONE_UP)
		if ((pGlobalDef->RunMode == VQCMODE_FIRST_Q)
		  ||(pGlobalDef->RunMode == VQCMODE_ONLY_Q))
		   		useDev = currUseDevForReduceQRiseU;
		break;
	case ZONE_NORMAL_UP:
	case ZONE_NORMAL_DOWN:
	case ZONE_NORMAL :
		if (Q.zone == ZONE_DOWN)			useDev = currUseDevForRiseQReduceU;
		else if (Q.zone == ZONE_UP) 		useDev = currUseDevForReduceQRiseU;
		break;
	case ZONE_DOWN :
		useDev = currUseDevForReduceQRiseU;
		if (Q.zone == ZONE_DOWN)
		if ((pGlobalDef->RunMode == VQCMODE_FIRST_Q)
		  ||(pGlobalDef->RunMode == VQCMODE_ONLY_Q))
				useDev = currUseDevForRiseQReduceU;
		break;
	default:break;
	}

	if (useDev!=NULL){
		if (U.zone == ZONE_UP){
			dUpQ   = useDev->DQ;
			dDownQ = pFatherZB->DQ;
		}
		else {
			dUpQ   = pFatherZB->DQ;
			dDownQ = useDev->DQ;
		}

		if (Q.zone == ZONE_UP){
			dUpU   = useDev->DU;
			dDownU = pFatherZB->DU;
		}
		else {
			dUpU   = pFatherZB->DU;
			dDownU = useDev->DU;
		}
	}
	else{
		if (U.zone == ZONE_UP){
			dUpQ   = 0;
			dDownQ = pFatherZB->DQ;
		}
		else {
			dUpQ   = pFatherZB->DQ;
			dDownQ = 0;
		}

		if (Q.zone == ZONE_UP){
			dUpU   = 0;
			dDownU = pFatherZB->DU;
		}
		else {
			dUpU   = pFatherZB->DU;
			dDownU = 0;
		}
	}
	ResetUQZone(dUpU,dDownU,dUpQ,dDownQ);

	if (lockReasonStatus & lockMask){
		sampleNum   = 1;
		U.meanValue = U.realValue;
		Q.meanValue = Q.realValue;
		integrateZone = GetIntegrateZoneWithQUValue(U.realValue, Q.realValue,0,0,0,0);
		return;
	}

	if (pGlobalDef->bUseMean){
		integrateZone = GetIntegrateZoneWithQUValue(U.meanValue, Q.meanValue,dUpU,dDownU,dUpQ,dDownQ);
		if (sampleNum < MaxSampleNum) return;
		askDrqActWeight = NORMAL_WEIGHT;
		askFjtActWeight = NORMAL_WEIGHT;
		AdjustWeightProc(integrateZone, askFjtActWeight, askDrqActWeight);

		CheckDrqUsedWillReciprocate(U.meanValue, Q.meanValue, useDev);

		AdjustMXVQCProc();
		return;
	}

	integrateZone = GetIntegrateZoneWithQUValue(U.realValue, Q.realValue,dUpU,dDownU,dUpQ,dDownQ);

	for(i=sampleNum-1;i>=0;i--){
		askDrqActWeight = NORMAL_WEIGHT;
		askFjtActWeight = NORMAL_WEIGHT;
		zone = GetIntegrateZoneWithQUValue(U.sampleValue[i], Q.sampleValue[i],dUpU,dDownU,dUpQ,dDownQ);

	    if ( zone == RUN_ZONE_LOCK){
		    sampleNum = i;
			continue;
	    }
		if (zone == RUN_ZONE_NORMAL){  //在正常范围，也要调整加权值
			if ((U.sampleValue[i]-U.currDownLimit) > U.oweValue)
			    askFjtUpWeight   -= U.oweWeight;
			else if ((U.currUpLimit-U.sampleValue[i]) > U.oweValue)
				askFjtDownWeight -= U.oweWeight;
			if ((Q.sampleValue[i]-Q.currDownLimit) > Q.oweValue)
			    askDrqOpenWeight   -= Q.oweWeight;
			else if ((Q.currUpLimit-Q.sampleValue[i]) > Q.oweValue)
				askDrqCloseWeight -= Q.oweWeight;
		    continue;
		}

		//不正常范围，要调整加权值
		askDrqActWeight = NORMAL_WEIGHT;
		askFjtActWeight = NORMAL_WEIGHT;
		if (U.sampleValue[i]>U.currUpLimit)   tf = U.sampleValue[i]-U.currUpLimit;
		if (U.sampleValue[i]<U.currDownLimit) tf = U.currDownLimit -U.sampleValue[i];
		if ((U.weight2!=0)&&(tf > U.fValue2)) askFjtActWeight = U.weight2;   //需加速动作
		else if ((U.weight1!=0)&&(tf > U.fValue1))	askFjtActWeight = U.weight1;
		if ((zone == RUN_ZONE_LEFT_UP)||(zone== RUN_ZONE_RIGHT_DOWN)) //考虑电容器动作对电压影响比较大，需加速动作电容器动作
				askDrqActWeight = askFjtActWeight;
			//需加速时，不考虑分接头调节对无功的影响
		if (Q.sampleValue[i]>Q.currUpLimit)   tf = Q.sampleValue[i]-Q.currUpLimit;
		if (Q.sampleValue[i]<Q.currDownLimit) tf = Q.currDownLimit -Q.sampleValue[i];
		if ((Q.weight2!=0)&&(tf > Q.fValue2))		askDrqActWeight = Q.weight2;
		else if ((Q.weight1!=0)&&(tf > Q.fValue1))  askDrqActWeight = Q.weight1;

		AdjustWeightProc(zone, askFjtActWeight, askDrqActWeight);

		CheckDrqUsedWillReciprocate(U.sampleValue[i], Q.sampleValue[i], useDev);
	}//end for
	if (askDrqOpenWeight < 0)  askDrqOpenWeight = 0;
	if (askDrqCloseWeight < 0) askDrqCloseWeight= 0;
	if (askFjtUpWeight < 0)    askFjtUpWeight	= 0;
	if (askFjtDownWeight < 0)  askFjtDownWeight = 0;

	if (pGlobalDef->DevControlMode== DEVMODE_ONLY_FJT){
		askDrqOpenWeight = 0;
		askDrqCloseWeight= 0;
	}

	if (pGlobalDef->DevControlMode== DEVMODE_ONLY_DRQ){
		askFjtDownWeight = 0;
		askFjtUpWeight	= 0;
	}

	AdjustMXVQCProc();
}