www.pudn.com > LJ_Pre_Modified_1.4.rar > LJDlg.cpp
// LJDlg.cpp : implementation file
//
#include "stdafx.h"
#include "LJ.h"
#include "LJDlg.h"
#include "OUTPUT.h"
#include "Matrix.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
CLJDlg *pLJDlg = NULL;
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CLJDlg dialog
CLJDlg::CLJDlg(CWnd* pParent /*=NULL*/)
: CDialog(CLJDlg::IDD, pParent) //参数初始化，设置评估场景，方便测试
{
//{{AFX_DATA_INIT(CLJDlg)
m_SBZKB = 30.0; //设备占空比
m_KXGH = 1.38; //空闲功耗
m_SMGL = 0.06; //睡眠功耗
m_FSGL = 17.0; //发送功耗
m_JSGL = 9.6; //接收功耗
m_DYGL = 10000.0; //电源
m_JDGZL = 5.0; //节点故障率
m_LJGZL = 5.0; //路径故障率
m_JDTXJL = 10.0; //节点通信距离
m_JDCGJL = 5.0; //节点传感距离
m_SJL = 100.0; //数据率
m_XZB = 20.0; //接收端信噪比
m_WML = 5.0; //误码率
m_CFXX = 5.0; //最大重传次数
m_DDD = 100.0; //端到端延时
m_LJHS = 20.0; //连接耗时
m_ZTHS = 10.0; //侦听耗时
m_XMHS = 20.0; //睡眠延时
m_CGQFGD = 100.0; //传感器覆盖率
m_JDRY = 100.0; //节点冗余度
m_LJRY = 50.0; //路径冗余度
m_WLGZSJ = 10.0; //网络故障时间
m_WLGZJG = 100.0; //网络故障时间间隔
m_LYZDGL = 5.0; //路由中断概率
m_LYXLKX = 30.0; //路由信令开销
m_PJLYCD = 5.0; //平均路由长度
m_ZCLJCD = 10.0; //最长路由长度
m_CGQWC = 5.0; //传感器误差
m_CGQFG = 100.0; //传感器覆盖度
m_JDPJ = 50.0; //信道接入公平性参数
m_XDRY = 50.0; //信道冗余
m_SJCCL = 0.3; //数据差错率
m_SJCSB = 98.4; //数据传输比
m_SJDSL = 0.3; //数据丢失率
m_WLJG = -1; //网络拓扑结构
m_PGSJ = 500.0; //评估时间
m_YSMY = 500;
m_YSXD = 500.0; //延时限度
m_WLJDSL = 100; //网络规模（节点数量）
m_BCD = 100; //数据包长度
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
pLJDlg = this;
KKX = 0; //可靠性量化值
KYX = 0; //可靠性综合效能：可用性
SCX = 0; //可靠性综合效能：生存性
YXX = 0; //可靠性综合效能：有效性
}
void CLJDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CLJDlg)
DDX_Text(pDX, IDC_SBZKB, m_SBZKB);
DDX_Text(pDX, IDC_KXGL, m_KXGH);
DDX_Text(pDX, IDC_SMGL, m_SMGL);
DDX_Text(pDX, IDC_FSGL, m_FSGL);
DDX_Text(pDX, IDC_JSGL, m_JSGL);
DDX_Text(pDX, IDC_JDGZL, m_JDGZL);
DDX_Text(pDX, IDC_LJGZL, m_LJGZL);
DDX_Text(pDX, IDC_JDTXJL, m_JDTXJL);
DDX_Text(pDX, IDC_JDCGJL, m_JDCGJL);
DDX_Text(pDX, IDC_SJL, m_SJL);
DDX_Text(pDX, IDC_XZB, m_XZB);
DDX_Text(pDX, IDC_WML, m_WML);
DDX_Text(pDX, IDC_CFXX, m_CFXX);
DDX_Text(pDX, IDC_DDD, m_DDD);
DDX_Text(pDX, IDC_LJHS, m_LJHS);
DDX_Text(pDX, IDC_ZTHS, m_ZTHS);
DDX_Text(pDX, IDC_XMHS, m_XMHS);
DDX_Text(pDX, IDC_CGQFGD, m_CGQFGD);
DDX_Text(pDX, IDC_JDRY, m_JDRY);
DDX_Text(pDX, IDC_LJRY, m_LJRY);
DDX_Text(pDX, IDC_WLGZSJ, m_WLGZSJ);
DDX_Text(pDX, IDC_WLGZJG, m_WLGZJG);
DDX_Text(pDX, IDC_LYZDGL, m_LYZDGL);
DDX_Text(pDX, IDC_LYXLKX, m_LYXLKX);
DDX_Text(pDX, IDC_PJLJCD, m_PJLYCD);
DDX_Text(pDX, IDC_ZCLJCD, m_ZCLJCD);
DDX_Text(pDX, IDC_CGQWC, m_CGQWC);
DDX_Text(pDX, IDC_CGQFG, m_CGQFG);
DDX_Text(pDX, IDC_JDPJ, m_JDPJ);
DDX_Text(pDX, IDC_XDRY, m_XDRY);
DDX_Text(pDX, IDC_SJCCL, m_SJCCL);
DDX_Text(pDX, IDC_SJCSB, m_SJCSB);
DDX_Text(pDX, IDC_SJDSL, m_SJDSL);
DDX_Radio(pDX, IDC_RADIO1, m_WLJG);
DDX_Text(pDX, IDC_PGSJ, m_PGSJ);
DDX_Text(pDX, IDC_YSXD, m_YSXD);
DDX_Text(pDX, IDC_WLJDSL, m_WLJDSL);
DDX_Text(pDX, IDC_BCD, m_BCD);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CLJDlg, CDialog)
//{{AFX_MSG_MAP(CLJDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CLJDlg message handlers
BOOL CLJDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
SetWindowText("IWSN可靠性评估工具");
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
}
void CLJDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CLJDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CLJDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
/************************************************************************/
/* 建立指标体系 */
/* 以矩阵类的形式建立指标体系 */
/* 后缀为_cntr的矩阵为评判对象指标集，经过处理后成为综合评价矩阵 */
/* 后缀为_qz的矩阵为评判权指 */
/************************************************************************/
CMatrix nengliang_cntr(1,5); //(1,5);
CMatrix liantong_cntr(1,6);
CMatrix ryrc_cntr(1,6);
CMatrix kktx_cntr(1,2);
CMatrix yxcs_cntr(1,3);
CMatrix ccqyx_cntr(1,2);
CMatrix ssx_cntr(1,4);
CMatrix yyly_cntr(1,3);
CMatrix scx_cntr(1,3);
CMatrix kyx_cntr(1,3);
CMatrix yxx_cntr(1,3);
CMatrix nengliang_qz(5,1); //(5,1,qz_nengliang);
CMatrix liantong_qz(6,1); //(6,1,qz_liantong);
CMatrix ryrc_qz(6,1); //(6,1,qz_ryrc);
CMatrix kktx_qz(2,1); //(2,1,qz_kktx);
CMatrix yxcs_qz(3,1); //(3,1,qz_yxcs);
CMatrix ccqyx_qz(2,1); //(2,1,qz_ccqyx);
CMatrix ssx_qz(4,1); //(4,1,qz_ssx);
CMatrix yyly_qz(3,1); //(3,1,qz_yyly);
CMatrix scx_qz(3,1); //(3,1,qz_scx);
CMatrix kyx_qz(3,1); //(3,1,qz_kyx);
CMatrix yxx_qz(3,1); //(3,1,qz_yxx);
double a_array[9] = { 0.42, 0.39, 0.31,
0.47, 0.40, 0.31,
0.11, 0.21, 0.38};
/************************************************************************/
/* 评估触发函数 */
/* 通过确认键触发评估过程 */
/* 初始化指标体系，进行归一化处理、向上综合的过程 */
/************************************************************************/
void CLJDlg::OnOK() //评估触发函数
{
// TODO: Add extra validation here
//CDialog::OnOK();
UpdateData(TRUE);
//SCX = this->shengcun();
//KYX = this->kyx();
//YXX = this->yxx();
int aa;
aa = GetCheckedRadioButton(IDC_RADIO4,IDC_RADIO6) - IDC_RADIO4;
/*
if (aa ==0 || aa == 1 || aa == 2)
{
KKX = (float)((int)((qz_kkx[aa][0] * SCX + qz_kkx[aa][1] * KYX + qz_kkx[aa][2] * YXX)*100))/100;
}
*/
sys_initiate(); //权值的初始化函数
ssx(); //实时性参数处理
yxcs(); //有效传输参数处理
ccqyx(); //传感参数处理
kktx(); //可靠通信参数处理
ryrc(); //冗余容错参数处理
liantongxing(); //连通性参数处理
nengliang(); //能量均衡参数处理
yyly(); //路由参数处理
shengcun(); //生存性参数设置
kyx(); //可用性参数设置
yxx(); //有效性参数设置
CMatrix ret(1,1); //声明矩阵，用于提取计算矩阵结果
double u_array[3]; //声明数组，用于矩阵元素的设置
ret = scx_cntr * scx_qz; //提取计算结果
SCX = ret.get(0,0);
u_array[0] = SCX;
ret = kyx_cntr * kyx_qz;
KYX = ret.get(0,0);
u_array[1] = KYX;
ret = yxx_cntr * yxx_qz;
YXX = ret.get(0,0);
u_array[2] = YXX;
//double u_array[3] = {SCX, KYX, YXX};
CMatrix u_1(1,3,u_array); //顶层可靠性贡献度
CMatrix a_1(3,3,a_array); //顶层权值
CMatrix d_1 = u_1 * a_1;
KKX = (double)((int)(d_1.get(0,aa)*100))/100; //根据取值
ret = ssx_cntr * ssx_qz;
if(!ret.get(0,0))
KKX *= 0.8f;
OUTPUT output;
output.DoModal();
/************************************************************************/
/* Matrix * Function Test */
/************************************************************************/
/*
double ma[4] = {0.2, 0.3, 0.4, 0.5};
double mb[4] = {0.5, 0.4, 0.3, 0.2};
//CMatrix * m1 = new CMatrix(2,2,ma);
//CMatrix * m2 = new CMatrix(2,2,mb);
CMatrix m1(2,2,ma);
CMatrix m2(2,2,mb);
CMatrix m3 = m1*m2;
double d[4] = {0,0,0,0};
d[0] = m3.get(0,0);
d[1] = m3.get(0,1);
d[2] = m3.get(1,0);
d[3] = m3.get(1,1);
d[3] = d[3];
*/
}
/************************************************************************/
/* 贡献度和权值体系的定义 */
/************************************************************************/
/*
struct cntr_system //贡献度体系
{
CMatrix nengliang_cntr; //(1,5);
CMatrix liantong_cntr; //(1,6);
CMatrix ryrc_cntr; //(1,6);
CMatrix kktx_cntr; //(1,2);
CMatrix yxcs_cntr; //(1,3);
CMatrix ccqyx_cntr; //(1,2);
CMatrix ssx_cntr; //(1,4);
CMatrix yyly_cntr; //(1,3);
CMatrix scx_cntr; //(1,3);
CMatrix kyx_cntr; //(1,3);
CMatrix yxx_cntr; //(1,3);
}cntr;
struct weight_system //权
{
CMatrix nengliang_qz; //(5,1,qz_nengliang);
CMatrix liantong_qz; //(6,1,qz_liantong);
CMatrix ryrc_qz; //(6,1,qz_ryrc);
CMatrix kktx_qz; //(2,1,qz_kktx);
CMatrix yxcs_qz; //(3,1,qz_yxcs);
CMatrix ccqyx_qz; //(2,1,qz_ccqyx);
CMatrix ssx_qz; //(4,1,qz_ssx);
CMatrix yyly_qz; //(3,1,qz_yyly);
CMatrix scx_qz; //(3,1,qz_scx);
CMatrix kyx_qz; //(3,1,qz_kyx);
CMatrix yxx_qz; //(3,1,qz_yxx);
}weight;
*/
double qz_nengliang[5] = {0.2,0.2,0.2,0.2,0.2f};
double qz_liantong[6] = {0.22,0.15,0.2,0.1,0.03,0.3};
double qz_ryrc[6]= {0.2,0.1,0.1,0.2,0.2,0.2};
double qz_kktx[2] = {0.5,0.5};
double qz_yxcs[3] = {0.3,0.4,0.3};
double qz_ccqyx[2] = {0.5,0.5};
double qz_ssx[4] = {0.56,0.15,0.15,0.14};
double qz_yyly[3] = {0.4,0.3,0.3};
double qz_scx[3] ={0.3,0.4,0.3};
double qz_kyx[4] = {0.35,0.2,0.2,0.25};
double qz_yxx[3] = {0.314,0.372,0.314};
void CLJDlg::sys_initiate(void) //舒适化权指矩阵
{
int i;
for(i=0; i<5; i++)
nengliang_qz.set(i,0,qz_nengliang[i]);
for(i=0; i<6; i++)
liantong_qz.set(i,0,qz_liantong[i]);
for(i=0; i<6; i++)
ryrc_qz.set(i,0,qz_ryrc[i]);
for(i=0; i<2; i++)
kktx_qz.set(i,0,qz_kktx[i]);
for(i=0; i<3; i++)
yxcs_qz.set(i,0,qz_yxcs[i]);
for(i=0; i<2; i++)
ccqyx_qz.set(i,0,qz_ccqyx[i]);
for(i=0; i<4; i++)
ssx_qz.set(i,0,qz_ssx[i]);
for(i=0; i<3; i++)
yyly_qz.set(i,0,qz_yyly[i]);
for(i=0; i<3; i++)
scx_qz.set(i,0,qz_scx[i]);
for(i=0; i<3; i++)
kyx_qz.set(i,0,qz_kyx[i]);
for(i=0; i<3; i++)
yxx_qz.set(i,0,qz_yxx[i]);
}
double CLJDlg::cal(double value1) //判断函数，评判级
{
double ret;
if(value1 >= 100.0)// || value1 < 0)
{
ret = 100.0;
}
else if (value1 >= 90.0 && value1 < 100.0)
{
ret = 90.0;
}
else if (value1 >= 80.0 && value1 < 90.0)
{
ret = 70.0;
}else if (value1 >= 70.0 && value1 < 80.0)
{
ret = 50.0;
}else if (value1 >= 50.0 && value1 < 70.0)
{
ret = 30.0;
}
else// if (value1 >= 0.0f && value1 < 50.0f)
{
ret = 0.0;
}
return ret;
}
void CLJDlg::nengliang() //确定能量参数的归一化值
{
double temp;
double x;
x = (m_SBZKB/100) * (m_DYGL);
if (m_SBZKB >= 80.0 && m_SBZKB <= 100.0)
{
temp = 100.0;
}else if(m_SBZKB >= 60.0 && m_SBZKB < 80.0)
{
temp = 90.0;
}else if (m_SBZKB >= 40.0 && m_SBZKB < 60.0)
{
temp = 70.0;
}else if (m_SBZKB >= 20.0 && m_SBZKB < 40.0)
{
temp = 60.0;
}else if (m_SBZKB >= 10.0 && m_SBZKB < 20.0)
{
temp = 30.0;
}else if (m_SBZKB >= 0.0 && m_SBZKB < 10.0)
{
temp = 10.0;
}
nengliang_cntr.set(0,0,temp); //矩阵的归一化参数设置
nengliang_cntr.set(0,1,cal(100*(1-m_KXGH/x)));
nengliang_cntr.set(0,2,cal(100*(1-m_FSGL/x)));
nengliang_cntr.set(0,3,cal(100*(1-m_SMGL/x)));
nengliang_cntr.set(0,4,cal(100*(1-m_JSGL/x)));
}
void CLJDlg::liantongxing()
{
double ret;
double temp=0.0,r = 0.0;
int rr;
double x;
x = m_JDCGJL/m_JDTXJL;
if (x >= 0.45 && x <= 0.55)
{
r = 90.0;
}
else if ((x >= 0.35 && x < 0.45) || (x >= 0.55 && x < 0.65))
{
r = 70.0;
}
else if ((x >= 0.25 && x < 0.35) || (x >= 0.65 && x < 0.75))
{
r = 50.0;
}
else if ((x >= 0.15 && x < 0.25) || (x >= 0.75 && x < 0.85))
{
r = 30.0;
}
else if ((x >= 0 && x < 0.15) || (x >= 0.85 && x < 1.0))
{
r = 10.0;
}
else
r = 0.0;
if(m_SJL >= 250.0)
{
temp = 100.0;
}
else if(m_SJL >= 150.0 && m_SJL < 250.0)
{
temp = 90.0;
}else if (m_SJL >= 100.0 && m_SJL < 150.0)
{
temp = 70.0;
}else if (m_SJL >= 80.0 && m_SJL < 100.0)
{
temp = 50.0;
}else if (m_SJL >= 50.0 && m_SJL < 80.0)
{
temp = 30.0;
}else if (m_SJL >= 0.0 && m_SJL < 50.0)
{
temp = 10.0;
}
else
{
temp = 0.0;
}
///////////////////////////////////////////
ret = N_Rel(m_JDGZL,m_PGSJ,m_JDRY);
ret = L_Rel(m_LJGZL,m_PGSJ,m_LJRY);
ret = cal(100 - m_JDGZL) * qz_liantong[0] + temp * qz_liantong[1] + cal(100 - m_LJGZL) * qz_liantong[2] + r * qz_liantong[3]
+ cal(((m_CFXX*10)>=100)?100:(m_CFXX*10+10)) * qz_liantong[4] ; //Modified
liantong_cntr.set(0,0,cal(100 - m_JDGZL)); //矩阵的归一化参数设置
liantong_cntr.set(0,1,temp);
liantong_cntr.set(0,2,cal(100 - m_LJGZL));
liantong_cntr.set(0,3,r);
liantong_cntr.set(0,4,cal(((m_CFXX*10)>=100)?100:(m_CFXX*10+10)));
rr = GetCheckedRadioButton(IDC_RADIO1,IDC_RADIO3) - IDC_RADIO1;
switch(rr)
{
case 0:
r = 70.0; break;
case 1:
r = 100.0; break;
case 2:
r = 85.0; break;
default:
r = 0.0;
break;
}
liantong_cntr.set(0,5,r);
}
void CLJDlg::OnCancel()
{
// TODO: Add extra cleanup here
CDialog::OnCancel();
}
void CLJDlg::ryrc()
{
ryrc_cntr.set(0,0,cal(m_JDRY));
ryrc_cntr.set(0,1,cal(m_XDRY));
ryrc_cntr.set(0,2,cal(m_LJRY));
ryrc_cntr.set(0,3,cal(m_CGQFGD));
ryrc_cntr.set(0,4,cal((100 - m_WLGZSJ)));
ryrc_cntr.set(0,5,cal(100*(1 - m_WLGZJG / m_PGSJ)));
}
void CLJDlg::kktx()
{
double temp;
if(m_XZB >= 100.0)
{
temp = 100.0;
}
if(m_XZB >= 50.0 && m_XZB < 100.0)
{
temp = 90.0;
}else if (m_XZB >= 20.0 && m_XZB < 50.0)
{
temp = 80.0;
}else if (m_XZB >= 10.0 && m_XZB < 20.0)
{
temp = 70.0;
}else if (m_XZB >= 5.0 && m_XZB < 10.0)
{
temp = 60.0;
}else if (m_XZB >= 0.0 && m_XZB < 5.0)
{
temp = 50.0;
}
kktx_cntr.set(0,0,temp);
kktx_cntr.set(0,1,cal(100 - m_WML));
}
void CLJDlg::yxcs()
{
yxcs_cntr.set(0,0,cal(100 - m_SJCCL));
yxcs_cntr.set(0,1,cal(m_SJCSB));
yxcs_cntr.set(0,2,cal(100 - m_SJDSL));
}
void CLJDlg::ccqyx()
{
ccqyx_cntr.set(0,0,cal(100 - m_CGQWC));
ccqyx_cntr.set(0,1,cal(m_CGQFG));
}
void CLJDlg::ssx()
{
ssx_cntr.set(0,0,(m_DDD / m_YSXD < 1) ? cal(100*(1 - m_DDD / m_YSXD)):0); //生存性矩阵的归一化参数设置
ssx_cntr.set(0,1,(m_DDD / m_YSXD < 1) ? cal(100*(1 - m_LJHS / m_DDD)):0);
ssx_cntr.set(0,2,(m_DDD / m_YSXD < 1) ? cal(100*(1 - m_ZTHS / m_DDD)):0);
}
void CLJDlg::yyly()
{
yyly_cntr.set(0,0,cal(100 - m_LYZDGL));
yyly_cntr.set(0,1,cal(100*(1 - m_PJLYCD / m_ZCLJCD)));
yyly_cntr.set(0,2,cal(100 - m_LYXLKX));
}
void CLJDlg::shengcun() //生存性综合
{
CMatrix ret(1,1);
ret = nengliang_cntr * nengliang_qz;
scx_cntr.set(0,0,ret.get(0,0));
ret = liantong_cntr * liantong_qz;
scx_cntr.set(0,1,ret.get(0,0));
ret = kktx_cntr * kktx_qz;
scx_cntr.set(0,2,ret.get(0,0));
}
void CLJDlg::kyx() //可用性综合
{
CMatrix ret(1,1);
ret = liantong_cntr * liantong_qz;
kyx_cntr.set(0,0,ret.get(0,0));
ret = ccqyx_cntr * ccqyx_qz;
kyx_cntr.set(0,1,ret.get(0,0));
ret = ryrc_cntr * ryrc_qz;
kyx_cntr.set(0,2,ret.get(0,0));
ret = yxcs_cntr * yxcs_qz;
kyx_cntr.set(0,3,ret.get(0,0));
}
void CLJDlg::yxx() //有效性综合
{
CMatrix ret(1,1);
ret = yxcs_cntr * yxcs_qz;
yxx_cntr.set(0,0,ret.get(0,0));
ret = ssx_cntr * ssx_qz;
yxx_cntr.set(0,1,ret.get(0,0));
ret = yyly_cntr * yyly_qz;
yxx_cntr.set(0,2,ret.get(0,0));
}
////////////////////////
/************************************************************************/
/* 节点可靠性的计算 */
/* 利用节点故障率、节点冗余和评估时间来确定节点的可靠息性 */
/* exp计算采用多项式展开来计算 */
/************************************************************************/
double CLJDlg::N_Rel(double NodeFault, double Period, double NRedundance)
{
double x;
double z = 1.0;
double m = 1.0;
double y = 1.0;
int i, j;
x = NodeFault*Period/NRedundance; //exp指数的确定
for(i=1; i<7; i++) //多项式展开
{
for(j=1; j<=i; j++)
{
z = z*x;
m = m*i;
}
y = y + z/m;
}
return 1/y;
}
/************************************************************************/
/* 路径可靠性的计算 */
/* 利用路径故障率、路径冗余和评估时间来确定节点的可靠息性 */
/* exp计算采用多项式展开来计算 */
/************************************************************************/
double CLJDlg::L_Rel(double LinkFault, double Period, double LRedundance)
{
double x;
double z = 1.0;
double m = 1.0;
double y = 1.0;
int i, j;
x = LinkFault*Period/LRedundance; //exp指数的确定
for(i=1; i<7; i++) //多项式展开
{
for(j=1; j<=i; j++)
{
z = z*x;
m = m*i;
}
y = y + z/m;
}
return 1/y;
}