dpf_calpferr.cpp

电力系统潮流程序adsfasdfasfd

/**************************************************************
* 所属模块 ： dpflow
* 文件路径 ： pas/dpflow
* 文 件 名 ： dpf_calpferr.cpp
* 文件功能 ： 统计潮流计算误差
* 继承关系 ：
* 操作系统 ： PC & UNIX
* 备    注 ：
* 历史记录 ：
*   时间            版本                作者             原因
*===============================================================
* 2004年04月08日      1.0               pas              created
***************************************************************/

#include "pub_ctx.h"
#include "dpf_pub.h"
#include "dpf_fun.h"
#include "system.h"
#include "scada_api/scada_public.h"
#include "../comm/GetAllRec.h"

#ifndef  _WINDOWS32
  #ifdef _ALPHA
    #include <sys/uswitch.h>
  #endif
#endif

#ifndef _DEFINE_HIDBVAR_AS_GLOBAL_
#define _DEFINE_HIDBVAR_AS_GLOBAL_
#endif
#include "dpf_pas.h"

void get_rtnet_result();


int main(int argc, char**argv)
{
#ifdef _ALPHA
  long uval = uswitch(USC_GET, 0);
  uval = uswitch(USC_SET, uval | USW_CORE);
  if (uval < 0)    perror("uswitch");
#endif

  CContext::SetContextNo(argc, argv,AC_REALTIME_NO);
  CCommArgs::Set(argc,argv,AP_PAS_DPF);
  if (AP_PAS_DPF != CCommArgs::AppNo()/10*10)
  {
    printf ("++++++++++ appno error, valid no is 2120 -- 2129, please check your input again!\n");
    return 0;
  }

  int    app_no = CCommArgs::AppNo();
  string app_name = CAppMap::GetSdbAppName(app_no);
  int    i(0), src_type(0);
  
  for (i=1; i<argc-1; ++i)
  {
    if(strcmp(argv[i],"-type")==0)
    {
      src_type = atoi(argv[i+1]);
      break;
    }
  }
  printf ("appno = %d\t appname = %s\t type = %d\n", app_no, app_name.c_str(), src_type);
  if (src_type < 0 || src_type > 4)
  {
    printf ("Error: para for -type is error! type = %s\n", argv[i+1]);
    exit(0);
  }
  
  dpf_access_db();
  if (0 == src_type) get_rtnet_result();
  dpf_cal_pferr_();

  char  msg[256];
  int   pnt = pferr1_->TOTALPNT; 
  float err = pferr1_->TOTALERR;  
  printf ("pnt=%d,err=%f\n",pnt,err); 
    
  strcpy (msg, "完成误差统计");
  
  ODB::CTableOp dpf_para(app_no, PARA_DPFLOW_EMS_NO);
  dpf_para.TableModify("totalpnt", (const char*)&pnt, sizeof(int)); 
  dpf_para.TableModify("totalerr", (const char*)&err, sizeof(float)); 
  dpf_para.TableModify("runmsg", msg, 80);

  short ctx_no(0);
  CContext::GetContextNo(ctx_no);
  string fam_name = merge_famnm_with_ctx(ctx_no);
  ListRefresh ("PNTERR", app_name, fam_name);

//
  int  k,hostid;
  char hostnm[32], usernm[32];

  strcpy(hostnm,CCommArgs::NodeName().c_str());
  strcpy(usernm,CCommArgs::UserName().c_str());

  NET_ODB::CTableNet table_node_info(PUBLIC, MNG_NODE_INFO_NO);
  struct NodeInfo
  {
    int  node_id;
    char node_name[40];
  };

  CBuffer get_result;
  if(table_node_info.TableGet("node_id, node_name", get_result) >= 0)
  {
    NodeInfo *node_info_ptr = (NodeInfo*)get_result.GetBufPtr();
    k = get_result.GetLength()/sizeof(NodeInfo);
    for (i=0; i<k; ++i)
    {
      if(0 == strcmp(node_info_ptr[i].node_name, hostnm))
      {
        hostid = node_info_ptr[i].node_id;
        break;
      }
    }
  }

  get_dpfop_msg (msg, app_no);

  if (pferrmom_->LV$ERCASE < MX$ERCASE) pferrmom_->LV$ERCASE++;
  k = pferrmom_->LV$ERCASE-1;
  pferr1_->TIME_ERCASE[k]   = time(NULL);
  pferr1_->ERR_ERCASE[k]    = err;
  pferr1_->HOSTID_ERCASE[k] = hostid;
  strncpy(pferr1_->HOSTNM_ERCASE[k],hostnm,HOSTNM_ERCASE$CHAR$SIZE);
  strncpy(pferr1_->USERNM_ERCASE[k],usernm,USERNM_ERCASE$CHAR$SIZE);
  strncpy(pferr1_->OPMSG_ERCASE[k],msg,OPMSG_ERCASE$CHAR$SIZE);
  
  SendAppChangeDataMsg(app_no);
  return 0;

}

  
struct VValue_DpfErr
{
        int id;
        float v_value;
	int v_bdfg;
        float v_value_cal;
};
const char* BS_FLD = "bs_id, v_value,v_bdfg,v_value_cal";

struct PqiValue_DpfErr
{
        int id;
        float p_value;
	int p_status;
        float p_value_cal;
        float q_value;
	int q_status;
        float q_value_cal;
        unsigned char open_fg;
};
const char* GN_FLD = "gn_id, p_value, p_status, p_value_cal, q_value, q_status, q_value_cal, open_fg";
const char* LD_FLD = "ld_id, p_value, p_status, p_value_cal, q_value, q_status, q_value_cal, open_fg";

struct PqiValuePid_DpfErr : PqiValue_DpfErr
{
        int parent_id;
};
const char* DOT_FLD = "acln_dot_id, p_value, p_status, p_value_cal, q_value, q_status, q_value_cal, acln_id, open_fg";
const char* TRWD_FLD = "trwd_id, p_value, p_status, p_value_cal, q_value, q_status, q_value_cal, tr_id, open_fg";

void get_rtnet_result()
{
	int app_no=AP_PAS_RTNET;
        vector<VValue_DpfErr> bs_info_vec;
        GetAllRec<NET_ODB::CTableNet>(app_no, BS_DEVICE_NO, BS_FLD, bs_info_vec);
        for(int nBs = 0; nBs < bs_info_vec.size(); ++nBs)
        {
                int nd_sub = ipmap_ -> NETSUB_BSID[bs_info_vec[nBs].id % 1000000 - 1] - 1;
                if(nd_sub >= 0)
                {
			netmon_->DTSQ_ND[nd_sub].VIOLATUP$M_ND=bool(bs_info_vec[nBs].v_bdfg&STATE_YC_BAD_DATA);
			if(netmon_->DTSQ_ND[nd_sub].VIOLATUP$M_ND)
				netbus_->A_ND[nd_sub]=bs_info_vec[nBs].v_value;
			else
				netbus_->A_ND[nd_sub]=bs_info_vec[nBs].v_value_cal;
                }
		int elcbus=netval_->I$ELCBUS_ND[nd_sub]-1;
		if(elcbus>=0)
		{
			netbus_->KV0_ELCBUS[elcbus]=netbus_->A_ND[nd_sub];
		}
        }

        vector<PqiValue_DpfErr> gn_info_vec;
        GetAllRec<NET_ODB::CTableNet>(app_no, GN_DEVICE_NO, GN_FLD, gn_info_vec);
        for(int nGn = 0; nGn < gn_info_vec.size(); ++ nGn)
        {
                int un_sub = ipmap_ -> NETSUB_UNID[gn_info_vec[nGn].id % 1000000 - 1] - 1;
                if(un_sub >= 0)
                {
			netmon_->DTSPQ_UN[un_sub].VIOLATUP$M_UN=bool(gn_info_vec[nGn].p_status&STATE_YC_BAD_DATA);
			netmon_->DTSPQ_UN[un_sub].VIOLATDN$M_UN=bool(gn_info_vec[nGn].q_status&STATE_YC_BAD_DATA);
			if(netmon_->DTSPQ_UN[un_sub].VIOLATUP$M_UN)
				netbus_ -> W0_UN[un_sub] = gn_info_vec[nGn].p_value;
			else
				netbus_ -> W0_UN[un_sub] = gn_info_vec[nGn].p_value_cal;
			if(netmon_->DTSPQ_UN[un_sub].VIOLATDN$M_UN)
				netbus_ -> R0_UN[un_sub] = gn_info_vec[nGn].q_value;
			else 
				netbus_ -> R0_UN[un_sub] = gn_info_vec[nGn].q_value_cal;
                }
        }

        vector<PqiValue_DpfErr> ld_info_vec;
        GetAllRec<NET_ODB::CTableNet>(app_no, LD_DEVICE_NO, LD_FLD, ld_info_vec);
        for(int nLd = 0; nLd < ld_info_vec.size(); ++ nLd)
        {
                int ld_sub = ipmap_ -> NETSUB_LDID[ld_info_vec[nLd].id % 1000000 - 1] - 1;
                if(ld_sub >= 0)
                {
			netmon_->DTSQ_LD[ld_sub].VIOLATUP$M_LD=bool(ld_info_vec[nLd].p_status&STATE_YC_BAD_DATA);
			netmon_->DTSQ_LD[ld_sub].VIOLATDN$M_LD=bool(ld_info_vec[nLd].q_status&STATE_YC_BAD_DATA);
			if(netmon_->DTSQ_LD[ld_sub].VIOLATUP$M_LD)
				netbus_ -> W0_LD[ld_sub] = ld_info_vec[nLd].p_value;
			else
				netbus_ -> W0_LD[ld_sub] = ld_info_vec[nLd].p_value_cal;
			if(netmon_->DTSQ_LD[ld_sub].VIOLATDN$M_LD)
				netbus_ -> R0_LD[ld_sub] = ld_info_vec[nLd].q_value;
			else
				netbus_ -> R0_LD[ld_sub] = ld_info_vec[nLd].q_value_cal;
                }
        }

        vector<PqiValuePid_DpfErr> dot_info_vec;
        GetAllRec<NET_ODB::CTableNet>(app_no, ACLN_DOT_NO, DOT_FLD, dot_info_vec);
        const int i_zero(0);
        for(int nDot = 0; nDot < dot_info_vec.size(); ++ nDot)
        {
                int id_sub = dot_info_vec[nDot].id % 1000000 - 1;
                int netsub = ipmap_ -> NETSUB_LN2ID[id_sub] - 1;
                if(netsub >= 0)
                {
                        if(0 == memcmp(&ipmap_ -> Q_LN2ID[id_sub], &i_zero, sizeof(ipmap_ -> Q_LN2ID[id_sub])))
                        {
				netmon_->DTSWQ_LN2[netsub].VIOLATUP$M_LN2=bool(dot_info_vec[nDot].p_status&STATE_YC_BAD_DATA);
				netmon_->DTSWQ_LN2[netsub].VIOLATDN$M_LN2=bool(dot_info_vec[nDot].q_status&STATE_YC_BAD_DATA);
				if(netmon_->DTSWQ_LN2[netsub].VIOLATUP$M_LN2)
					netbus_ -> W0_LN2[netsub] = dot_info_vec[nDot].p_value;
				else
					netbus_ -> W0_LN2[netsub] = dot_info_vec[nDot].p_value_cal;
				if(netmon_->DTSWQ_LN2[netsub].VIOLATDN$M_LN2)
					netbus_ -> R0_LN2[netsub] = dot_info_vec[nDot].q_value;
				else
					netbus_ -> R0_LN2[netsub] = dot_info_vec[nDot].q_value_cal;

                        }
                        else if(ipmap_ -> Q_LN2ID[id_sub].EQLDFG$M_LN2ID)
                        {
				netmon_->DTSQ_LD[netsub].VIOLATUP$M_LD=bool(dot_info_vec[nDot].p_status&STATE_YC_BAD_DATA);
				netmon_->DTSQ_LD[netsub].VIOLATDN$M_LD=bool(dot_info_vec[nDot].q_status&STATE_YC_BAD_DATA);
				if(netmon_->DTSQ_LD[netsub].VIOLATUP$M_LD)
					netbus_ -> W0_LD[netsub] = dot_info_vec[nDot].p_value;
				else
					netbus_ -> W0_LD[netsub] = dot_info_vec[nDot].p_value_cal;
				if(netmon_->DTSQ_LD[netsub].VIOLATDN$M_LD)
					netbus_ -> R0_LD[netsub] = dot_info_vec[nDot].q_value;
				else
					netbus_ -> R0_LD[netsub] = dot_info_vec[nDot].q_value_cal;
                        }
                        else if(ipmap_ -> Q_LN2ID[id_sub].EQUNFG$M_LN2ID)
                        {
				netmon_->DTSPQ_UN[netsub].VIOLATUP$M_UN=bool(dot_info_vec[nDot].p_status&STATE_YC_BAD_DATA);
				netmon_->DTSPQ_UN[netsub].VIOLATDN$M_UN=bool(dot_info_vec[nDot].q_status&STATE_YC_BAD_DATA);
				if(netmon_->DTSPQ_UN[netsub].VIOLATUP$M_UN)
					netbus_ -> W0_UN[netsub] = -dot_info_vec[nDot].p_value;
				else
					netbus_ -> W0_UN[netsub] = -dot_info_vec[nDot].p_value_cal;
				if(netmon_->DTSPQ_UN[netsub].VIOLATDN$M_UN)
					netbus_ -> R0_UN[netsub] = -dot_info_vec[nDot].q_value;
				else
					netbus_ -> R0_UN[netsub] = -dot_info_vec[nDot].q_value_cal;
                        }
                }
        }

        vector<PqiValuePid_DpfErr> trwd_info_vec;
        GetAllRec<NET_ODB::CTableNet>(app_no, TRWD_DEVICE_NO, TRWD_FLD, trwd_info_vec);
        for(int nTrwd = 0; nTrwd < trwd_info_vec.size(); ++nTrwd)
        {
                int id_sub = trwd_info_vec[nTrwd].id % 1000000 - 1;
                int netsub = ipmap_ -> NETSUB_XF2ID[id_sub] - 1;
                if(netsub >= 0)
                {
                        if(ipmap_ -> Q_XF2ID[id_sub].TERMFG$M_XF2ID)
                        {
				netmon_->DTSQ_LD[netsub].VIOLATUP$M_LD=bool(trwd_info_vec[nTrwd].p_status&STATE_YC_BAD_DATA);
				netmon_->DTSQ_LD[netsub].VIOLATDN$M_LD=bool(trwd_info_vec[nTrwd].q_status&STATE_YC_BAD_DATA);
				if(netmon_->DTSQ_LD[netsub].VIOLATUP$M_LD)
					netbus_ -> W0_LD[netsub] = trwd_info_vec[nTrwd].p_value;
				else
					netbus_ -> W0_LD[netsub] = trwd_info_vec[nTrwd].p_value_cal;
				if(netmon_->DTSQ_LD[netsub].VIOLATDN$M_LD)
					netbus_ -> R0_LD[netsub] = trwd_info_vec[nTrwd].q_value;
				else
					netbus_ -> R0_LD[netsub] = trwd_info_vec[nTrwd].q_value_cal;
                        }
                        else
                        {
				netmon_->DTSXQ_XF2[netsub].VIOLATUP$M_XF2=bool(trwd_info_vec[nTrwd].p_status&STATE_YC_BAD_DATA);
				netmon_->DTSXQ_XF2[netsub].VIOLATDN$M_XF2=bool(trwd_info_vec[nTrwd].q_status&STATE_YC_BAD_DATA);
				if(netmon_->DTSXQ_XF2[netsub].VIOLATUP$M_XF2)
					netbus_ -> W0_XF2[netsub] = trwd_info_vec[nTrwd].p_value;
				else
					netbus_ -> W0_XF2[netsub] = trwd_info_vec[nTrwd].p_value_cal;
				if(netmon_->DTSXQ_XF2[netsub].VIOLATDN$M_XF2)
					netbus_ -> R0_XF2[netsub] = trwd_info_vec[nTrwd].q_value;
				else
					netbus_ -> R0_XF2[netsub] = trwd_info_vec[nTrwd].q_value_cal;
                        }
                }
        }

}