395 lines
14 KiB
Python
395 lines
14 KiB
Python
import numpy as np
|
||
from typing import Dict
|
||
from .utils import NetworkUtils
|
||
|
||
|
||
class RelationCalculator:
|
||
"""关系强度计算器"""
|
||
|
||
def __init__(self, nodes_data: Dict, cfg):
|
||
"""
|
||
初始化
|
||
:param nodes_data: 节点数据
|
||
:param auxiliary_data: 辅助数据（接口标准、角色匹配等）
|
||
"""
|
||
self.nodes_data = nodes_data
|
||
self.utils = NetworkUtils()
|
||
self.cfg = cfg
|
||
|
||
def _weights(self, rel: str):
|
||
return self.cfg["W_REL"][rel]
|
||
|
||
def _lambda(self, rel: str):
|
||
return self.cfg["LAMBDA"][rel]
|
||
|
||
def calculate_IS_relation(self, i: str, j: str) -> float:
|
||
"""
|
||
计算情报保障关系强度
|
||
L_IS(i,j) = w_f·M_IS_F + w_s·M_IS_S + w_t·M_IS_T + w_p·M_IS_P + w_i·M_IS_I
|
||
"""
|
||
# 权重参数（根据1.3.pdf）
|
||
w = self._weights("IS")
|
||
# 提取节点数据
|
||
node_i = self.nodes_data['nodes'][i]
|
||
node_j = self.nodes_data['nodes'][j]
|
||
|
||
# 1. 功能维度 M_IS_F
|
||
f_i_IA = node_i['function_vector']['f_IA']
|
||
f_j_avg = (
|
||
node_j['function_vector']['f_CC'] +
|
||
node_j['function_vector']['f_IC'] +
|
||
node_j['function_vector']['f_CS'] +
|
||
node_j['function_vector']['f_CPS']
|
||
) / 4
|
||
|
||
std_ij = self.utils.get_interface_standard(node_i, node_j)
|
||
r_ij = self.utils.get_role_match(node_i, node_j)
|
||
M_IS_F = f_i_IA * f_j_avg * std_ij * r_ij
|
||
|
||
# 2. 空间维度 M_IS_S
|
||
d_ij = self.utils.calculate_distance(
|
||
node_i['spatial']['position'],
|
||
node_j['spatial']['position']
|
||
)
|
||
lambda_IS = self._lambda("IS")
|
||
R_match = self.utils.calculate_range_match(
|
||
node_i['spatial']['effective_radius'],
|
||
node_j['spatial']['effective_radius'],
|
||
d_ij
|
||
)
|
||
|
||
s_area = self.utils.get_area_relation(node_i, node_j)
|
||
M_IS_S = np.exp(-d_ij / lambda_IS) * R_match * s_area
|
||
|
||
# 3. 时间维度
|
||
alpha = self.cfg["TIME"]["alpha"]
|
||
beta = self.cfg["TIME"]["beta"]
|
||
gamma = self.cfg["TIME"]["gamma"]
|
||
|
||
fresh_i = np.exp(-gamma * node_i['temporal']['data_age'])
|
||
t_i_resp = np.exp(-alpha * node_i['temporal']['response_time'])
|
||
|
||
w_ij = self.utils.calculate_time_window_overlap(node_i, node_j)
|
||
|
||
M_IS_T = fresh_i * t_i_resp * w_ij
|
||
|
||
# 4. 性能维度 M_IS_P
|
||
p_i_core = node_i['performance']['core_performance']
|
||
mtbf_max = self.nodes_data['global_params']['mtbf_max']
|
||
p_i_rel = node_i['performance']['mtbf'] / mtbf_max
|
||
M_IS_P = p_i_core * p_i_rel
|
||
|
||
# 5. 交互维度 M_IS_I
|
||
prot_ij = self.utils.get_protocol_compatibility(node_i, node_j)
|
||
fmt_ij = self.utils.get_format_compatibility(node_i, node_j)
|
||
sec_ij = self.utils.get_security_compatibility(node_i, node_j)
|
||
hist_ij = self.utils.get_interaction_history(node_i, node_j)
|
||
M_IS_I = ((prot_ij + fmt_ij + sec_ij) / 3) * hist_ij
|
||
|
||
# 综合计算
|
||
L_IS = (w["w_f"] * M_IS_F + w["w_s"] * M_IS_S + w["w_t"] * M_IS_T +
|
||
w["w_p"] * M_IS_P + w["w_i"] * M_IS_I)
|
||
|
||
return L_IS
|
||
|
||
def calculate_CC_relation(self, i: str, j: str) -> float:
|
||
"""
|
||
计算指挥控制关系强度
|
||
L_CC(i,j) = w_f·M_CC_F + w_s·M_CC_S + w_t·M_CC_T + w_p·M_CC_P + w_i·M_CC_I
|
||
"""
|
||
# 权重参数
|
||
w = self._weights("CC")
|
||
lambda_CC = self._lambda("CC")# 根据公式，指挥控制距离敏感性更高
|
||
|
||
node_i = self.nodes_data['nodes'][i]
|
||
node_j = self.nodes_data['nodes'][j]
|
||
|
||
# 1. 功能维度 M_CC_F
|
||
f_i_CC = node_i['function_vector']['f_CC']
|
||
f_j_sum = sum([
|
||
node_j['function_vector']['f_IA'],
|
||
node_j['function_vector']['f_IT'],
|
||
node_j['function_vector']['f_IC'],
|
||
node_j['function_vector']['f_CS'],
|
||
node_j['function_vector']['f_DP'],
|
||
node_j['function_vector']['f_CPS']
|
||
])
|
||
f_j_avg = f_j_sum / 6
|
||
|
||
std_ij = self.utils.get_interface_standard(node_i, node_j)
|
||
r_ij = self.utils.get_role_match(node_i, node_j)
|
||
M_CC_F = f_i_CC * f_j_avg * std_ij * r_ij
|
||
|
||
# 2. 空间维度 M_CC_S
|
||
d_ij = self.utils.calculate_distance(
|
||
node_i['spatial']['position'],
|
||
node_j['spatial']['position']
|
||
)
|
||
|
||
R_match = self.utils.calculate_range_match(
|
||
node_i['spatial']['effective_radius'],
|
||
node_j['spatial']['effective_radius'],
|
||
d_ij
|
||
)
|
||
|
||
s_area = self.utils.get_area_relation(node_i, node_j)
|
||
M_CC_S = np.exp(-d_ij / lambda_CC) * R_match * s_area
|
||
|
||
# 3. 时间维度 M_CC_T
|
||
alpha = self.cfg["TIME"]["alpha"]
|
||
beta = self.cfg["TIME"]["beta"]
|
||
gamma = self.cfg["TIME"]["gamma"]
|
||
|
||
t_i_resp = np.exp(-alpha * node_i['temporal']['response_time'])
|
||
t_i_cycle = np.exp(-beta * node_i['temporal']['cycle_time'])
|
||
|
||
w_ij = self.utils.calculate_time_window_overlap(node_i, node_j)
|
||
|
||
M_CC_T = t_i_resp * t_i_cycle * w_ij
|
||
|
||
# 4. 性能维度 M_CC_P
|
||
p_i_core = node_i['performance']['core_performance']
|
||
p_i_surv = node_i['performance']['survivability']
|
||
mtbf_max = self.nodes_data['global_params']['mtbf_max']
|
||
p_i_rel = node_i['performance']['mtbf'] / mtbf_max
|
||
M_CC_P = p_i_core * p_i_surv * p_i_rel
|
||
|
||
# 5. 交互维度 M_CC_I
|
||
prot_ij = self.utils.get_protocol_compatibility(node_i, node_j)
|
||
sec_ij = self.utils.get_security_compatibility(node_i, node_j)
|
||
org_ij = self.utils.get_organization_relation(node_i, node_j)
|
||
hist_ij = self.utils.get_interaction_history(node_i, node_j)
|
||
M_CC_I = ((prot_ij + sec_ij + org_ij) / 3) * hist_ij
|
||
|
||
# 综合计算
|
||
L_CC = (w["w_f"] * M_CC_F + w["w_s"] * M_CC_S + w["w_t"] * M_CC_T +
|
||
w["w_p"] * M_CC_P + w["w_i"] * M_CC_I)
|
||
|
||
return L_CC
|
||
|
||
def calculate_SF_relation(self, i: str, j: str) -> float:
|
||
"""
|
||
计算状态反馈关系强度
|
||
L_SF(i,j) = w_f·M_SF_F + w_s·M_SF_S + w_t·M_SF_T + w_p·M_SF_P + w_i·M_SF_I
|
||
"""
|
||
# 权重参数
|
||
w = self._weights("SF")
|
||
lambda_SF = self._lambda("SF")
|
||
|
||
node_i = self.nodes_data['nodes'][i]
|
||
node_j = self.nodes_data['nodes'][j]
|
||
|
||
# 1. 功能维度 M_SF_F
|
||
f_i_sum = sum([
|
||
node_i['function_vector']['f_IA'],
|
||
node_i['function_vector']['f_IT'],
|
||
node_i['function_vector']['f_IC'],
|
||
node_i['function_vector']['f_CS'],
|
||
node_i['function_vector']['f_DP'],
|
||
node_i['function_vector']['f_CPS']
|
||
])
|
||
f_i_avg = f_i_sum / 6
|
||
f_j_CC = node_j['function_vector']['f_CC']
|
||
|
||
std_ij = self.utils.get_interface_standard(node_i, node_j)
|
||
r_ij = self.utils.get_role_match(node_i, node_j)
|
||
M_SF_F = f_i_avg * f_j_CC * std_ij * r_ij
|
||
|
||
# 2. 空间维度 M_SF_S
|
||
d_ij = self.utils.calculate_distance(
|
||
node_i['spatial']['position'],
|
||
node_j['spatial']['position']
|
||
)
|
||
|
||
R_match = self.utils.calculate_range_match(
|
||
node_i['spatial']['effective_radius'],
|
||
node_j['spatial']['effective_radius'],
|
||
d_ij
|
||
)
|
||
|
||
s_area = self.utils.get_area_relation(node_i, node_j)
|
||
M_SF_S = np.exp(-d_ij / lambda_SF) * R_match * s_area
|
||
|
||
# 3. 时间维度 M_SF_T（状态反馈对时间敏感）
|
||
alpha = self.cfg["TIME"]["alpha"]
|
||
beta = self.cfg["TIME"]["beta"]
|
||
gamma = self.cfg["TIME"]["gamma"]
|
||
|
||
fresh_i = np.exp(-gamma * node_i['temporal']['data_age'])
|
||
t_i_resp = np.exp(-alpha * node_i['temporal']['response_time'])
|
||
|
||
w_ij = self.utils.calculate_time_window_overlap(node_i, node_j)
|
||
|
||
M_SF_T = fresh_i * t_i_resp * w_ij
|
||
|
||
# 4. 性能维度 M_SF_P
|
||
p_i_core = node_i['performance']['core_performance']
|
||
mtbf_max = self.nodes_data['global_params']['mtbf_max']
|
||
p_i_rel = node_i['performance']['mtbf'] / mtbf_max
|
||
M_SF_P = p_i_core * p_i_rel
|
||
|
||
# 5. 交互维度 M_SF_I
|
||
prot_ij = self.utils.get_protocol_compatibility(node_i, node_j)
|
||
fmt_ij = self.utils.get_format_compatibility(node_i, node_j)
|
||
sec_ij = self.utils.get_security_compatibility(node_i, node_j)
|
||
hist_ij = self.utils.get_interaction_history(node_i, node_j)
|
||
M_SF_I = ((prot_ij + fmt_ij + sec_ij) / 3) * hist_ij
|
||
|
||
# 综合计算
|
||
L_SF = (w["w_f"] * M_SF_F + w["w_s"] * M_SF_S + w["w_t"] * M_SF_T +
|
||
w["w_p"] * M_SF_P + w["w_i"] * M_SF_I)
|
||
|
||
return L_SF
|
||
|
||
def calculate_PD_relation(self, i: str, j: str) -> float:
|
||
"""
|
||
计算平台部署关系强度
|
||
L_PD(i,j) = w_f·M_PD_F + w_s·M_PD_S + w_t·M_PD_T + w_p·M_PD_P + w_i·M_PD_I
|
||
"""
|
||
# 权重参数
|
||
w = self._weights("PD")
|
||
lambda_PD = self._lambda("PD")
|
||
|
||
node_i = self.nodes_data['nodes'][i]
|
||
node_j = self.nodes_data['nodes'][j]
|
||
|
||
# 1. 功能维度 M_PD_F
|
||
f_i_DP = node_i['function_vector']['f_DP']
|
||
f_J_sum = sum([
|
||
node_j['function_vector']['f_IA'],
|
||
node_j['function_vector']['f_IT'],
|
||
node_j['function_vector']['f_IC'],
|
||
node_j['function_vector']['f_CS'],
|
||
])
|
||
f_J_avg = f_J_sum / 4
|
||
|
||
# 修复：直接传递节点数据
|
||
std_ij = self.utils.get_interface_standard(node_i, node_j)
|
||
r_ij = self.utils.get_role_match(node_i, node_j)
|
||
M_PD_F = f_i_DP * f_J_avg * std_ij * r_ij
|
||
|
||
# 2. 空间维度 M_PD_S（平台部署对空间要求高）
|
||
d_ij = self.utils.calculate_distance(
|
||
node_i['spatial']['position'],
|
||
node_j['spatial']['position']
|
||
)
|
||
|
||
R_match = self.utils.calculate_range_match(
|
||
node_i['spatial']['effective_radius'],
|
||
node_j['spatial']['effective_radius'],
|
||
d_ij
|
||
)
|
||
# 修复：直接传递节点数据
|
||
s_area = self.utils.get_area_relation(node_i, node_j)
|
||
if d_ij <= self.cfg["PD_SGM"]:
|
||
M_PD_S = 1
|
||
else:
|
||
M_PD_S = np.exp(-d_ij / lambda_PD) * R_match * s_area
|
||
|
||
# 3. 时间维度 M_PD_T
|
||
alpha = self.cfg["TIME"]["alpha"]
|
||
beta = self.cfg["TIME"]["beta"]
|
||
gamma = self.cfg["TIME"]["gamma"]
|
||
|
||
t_i_resp = np.exp(-alpha * node_i['temporal']['response_time'])
|
||
t_i_cycle = np.exp(-beta * node_i['temporal']['cycle_time'])
|
||
|
||
w_ij = self.utils.calculate_time_window_overlap(node_i, node_j)
|
||
|
||
M_PD_T = t_i_resp * t_i_cycle * w_ij
|
||
|
||
# 4. 性能维度 M_PD_P
|
||
p_i_core = node_i['performance']['core_performance']
|
||
# 部署平台的生存能力
|
||
p_i_surv = node_i['performance']['survivability']
|
||
M_PD_P = p_i_core * p_i_surv
|
||
|
||
# 5. 交互维度 M_PD_I
|
||
prot_ij = self.utils.get_protocol_compatibility(node_i, node_j)
|
||
fmt_ij = self.utils.get_format_compatibility(node_i, node_j)
|
||
# 注意：这里std_ij已经在上面计算过了
|
||
M_PD_I = (prot_ij + fmt_ij + std_ij) / 3
|
||
|
||
# 综合计算
|
||
L_PD = (w["w_f"] * M_PD_F + w["w_s"] * M_PD_S + w["w_t"] * M_PD_T +
|
||
w["w_p"] * M_PD_P + w["w_i"] * M_PD_I)
|
||
|
||
return L_PD
|
||
|
||
def calculate_CO_relation(self, i: str, j: str) -> float:
|
||
"""
|
||
计算协同作战关系强度
|
||
L_CO(i,j) = w_f·M_CO_F + w_s·M_CO_S + w_t·M_CO_T + w_p·M_CO_P + w_i·M_CO_I
|
||
"""
|
||
# 权重参数
|
||
w = self._weights("CO")
|
||
lambda_CO = self._lambda("CO")
|
||
node_i = self.nodes_data['nodes'][i]
|
||
node_j = self.nodes_data['nodes'][j]
|
||
|
||
# 1. 功能维度 M_CO_F
|
||
# 协同作战需要多个功能匹配
|
||
f_i_avg = sum(node_i['function_vector'].values()) / len(node_i['function_vector'])
|
||
f_j_avg = sum(node_j['function_vector'].values()) / len(node_j['function_vector'])
|
||
|
||
std_ij = self.utils.get_interface_standard(node_i, node_j)
|
||
r_ij = self.utils.get_role_match(node_i, node_j)
|
||
M_CO_F = f_i_avg * f_j_avg * std_ij * r_ij
|
||
|
||
# 2. 空间维度 M_CO_S
|
||
d_ij = self.utils.calculate_distance(
|
||
node_i['spatial']['position'],
|
||
node_j['spatial']['position']
|
||
)
|
||
|
||
R_match = self.utils.calculate_range_match(
|
||
node_i['spatial']['effective_radius'],
|
||
node_j['spatial']['effective_radius'],
|
||
d_ij
|
||
)
|
||
|
||
s_area = self.utils.get_area_relation(node_i, node_j)
|
||
M_CO_S = np.exp(-d_ij / lambda_CO) * R_match * s_area
|
||
|
||
# 3. 时间维度 M_CO_T（协同需要时间同步）
|
||
alpha = self.cfg["TIME"]["alpha"]
|
||
beta = self.cfg["TIME"]["beta"]
|
||
gamma = self.cfg["TIME"]["gamma"]
|
||
|
||
t_i_resp = np.exp(-alpha * node_i['temporal']['response_time'])
|
||
t_j_resp = np.exp(-alpha * node_j['temporal']['response_time'])
|
||
|
||
t_i_cycle = np.exp(-beta * node_i['temporal']['cycle_time'])
|
||
t_j_cycle = np.exp(-beta * node_j['temporal']['cycle_time'])
|
||
|
||
w_ij = self.utils.calculate_time_window_overlap(node_i, node_j)
|
||
|
||
M_CO_T = (t_i_resp + t_j_resp) * (t_i_cycle + t_j_cycle) * w_ij * 0.25
|
||
|
||
# 4. 性能维度 M_CO_P
|
||
p_i_core = node_i['performance']['core_performance']
|
||
p_j_core = node_j['performance']['core_performance']
|
||
|
||
mtbf_max = self.nodes_data['global_params']['mtbf_max']
|
||
p_i_rel = node_i['performance']['mtbf'] / mtbf_max
|
||
p_j_rel = node_j['performance']['mtbf'] / mtbf_max
|
||
|
||
p_i_surv = node_i['performance']['survivability']
|
||
p_j_surv = node_j['performance']['survivability']
|
||
# 协同性能取平均
|
||
M_CO_P = ((p_i_core + p_j_core) / 2) * ((p_i_rel + p_j_rel) / 2) * ((p_i_surv + p_j_surv) / 2)
|
||
|
||
# 5. 交互维度 M_CO_I
|
||
prot_ij = self.utils.get_protocol_compatibility(node_i, node_j)
|
||
fmt_ij = self.utils.get_format_compatibility(node_i, node_j)
|
||
sec_ij = self.utils.get_security_compatibility(node_i, node_j)
|
||
org_ij = self.utils.get_organization_relation(node_i, node_j)
|
||
hist_ij = self.utils.get_interaction_history(node_i, node_j)
|
||
M_CO_I = ((prot_ij + fmt_ij + sec_ij + org_ij) / 4) * hist_ij
|
||
|
||
# 综合计算
|
||
L_CO = (w["w_f"] * M_CO_F + w["w_s"] * M_CO_S + w["w_t"] * M_CO_T +
|
||
w["w_p"] * M_CO_P + w["w_i"] * M_CO_I)
|
||
|
||
|
||
return L_CO |