ljdlg.cpp

针对工业无线传感器网络的应用特点

/************************************************************************/
/*						贡献度和权值体系的定义							*/
/************************************************************************/
/*
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;
}