def slot_terminate_simulation(self):
# 加一步状态检测
if self.flag == "running":
# 加一步询问
reply = QtWidgets.QMessageBox.question(
self, "Terminate Simulation",
"Are you sure you want to teminate this simulation?",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if reply == QtWidgets.QMessageBox.Yes:
self.MyThread.terminate()
self.end_moment = datetime.now()
self.service_msg_log_text.append(
str(self.end_moment) + ": Simulation task terminated.")
record_dom = read_xml(self.record_dir_path_edit.text() +
"/Simulation_Record.xml")
record_dom_root = record_dom.getElementsByTagName("Result")[0]
record_dom_root.setAttribute("EndMoment", str(self.end_moment))
record_dom_root.setAttribute(
"TimeConsuming", str(self.end_moment - self.start_moment))
write_xml(
self.record_dir_path_edit.text() +
"/Simulation_Record.xml", record_dom)
self.current_generation = 0
self.flag = "waiting"
self.start_btn.setEnabled(True)
self.pause_btn.setEnabled(False)
self.MyThread.flag = False
self.MyThread.current_generation = 0
self.start_moment = None
self.end_moment = None
def start_check(self):
if self.members_xml_path_edit.text() is "" or \
self.def_xml_path_edit.text() is "" or \
self.record_dir_path_edit.text() is "" or \
self.version_edit.text() is "" or \
self.step_size_Edit.text() is "" or \
self.ex_ID_edit.text() is "" or \
self.step_size_Edit.text() is "":
return False
else:
record_dom = read_xml(self.record_dir_path_edit.text() +
"/Simulation_Record.xml")
record_dom_root = record_dom.getElementsByTagName("Result")[0]
record_dom_root.setAttribute("ID", self.ex_ID_edit.text())
record_dom_root.setAttribute("version", self.version_edit.text())
record_dom_root.setAttribute("MetaMemberID",
self.meta_member_ID_edit.text())
record_dom_root.setAttribute("DefinitionID",
self.definition_ID_edit.text())
record_dom_root.setAttribute("RecordStepSize",
self.step_size_Edit.text())
record_dom_root.setAttribute("Inherited",
str(eval(self.inherited_Edit.text())))
record_dom_root.setAttribute("Datetime",
self.modify_dateEdit.text())
self.start_moment = datetime.now()
record_dom_root.setAttribute("StartMoment", str(self.start_moment))
write_xml(
self.record_dir_path_edit.text() + "/Simulation_Record.xml",
record_dom)
return True
def slot_btn_set_record_path(self):
"""
设置仿真结果路径保存的槽函数
:return: no return
"""
dir_record_path = QtWidgets.QFileDialog.getExistingDirectory(
self, "选择仿真记录文件夹", os.getcwd())
now = datetime.now()
str_now = now.strftime("%Y-%m-%d %H-%M-%S")
if dir_record_path == "":
self.service_msg_log_text.append(str_now + ': ' +
'Unselect record save path.')
else:
self.record_dir_path_edit.setText(dir_record_path + "/" + str_now)
self.service_msg_log_text.append(
str(datetime.now()) + ': ' + 'Set record dictionary to: ' +
dir_record_path)
if not os.path.exists(self.record_dir_path_edit.text()):
os.mkdir(self.record_dir_path_edit.text())
# 需要有一个清空当前文件夹内容的操作
# 需要初始化生成一个xml基础文件
res = "<%s>" "</%s>" % ("Result", "Result")
record_dom = parseString(res)
root = record_dom.getElementsByTagName("Result")[0]
first_record_node = record_dom.createElement("Record")
for v in external_func.global_attribute_dict.values():
first_record_node.setAttribute(
v['aName'], str(self.global_dict[v['aName']]))
first_record_node.setAttribute("round",
str(self.current_generation))
root.appendChild(first_record_node)
write_xml(
self.record_dir_path_edit.text() + "/Simulation_Record.xml",
record_dom)
def save_scripts_to_xml(self):
"""
保存脚本列表设置到xml文件中，保存成功为True，失败为False。
:return:bool
"""
# 设置保存路径，为本项目下的external_file文件夹
save_path = "external_module_file"
# 设置文件名
file_name = "script.xml"
# 保存表格中的内容
doc = xml.dom.minidom.Document()
SCRIPTS = doc.createElement('Scripts')
doc.appendChild(SCRIPTS)
for row in range(self.script_table_widget.rowCount()):
SCRIPT = doc.createElement('Script')
SCRIPT.setAttribute("id", str(row))
for col in range(self.script_table_widget.columnCount()):
# 在第一列，需要判断输入的迭代数是否合法
if col == 0:
the_round = self.script_table_widget.item(row, col).text()
try:
# 需要判断一下在round列中的输入是不是int且不大于回合数设置
if int(the_round) < int(self.generation_Edit.text()):
SCRIPT.setAttribute("round", the_round)
else:
QtWidgets.QMessageBox.critical(
self, "error",
"in row: {}\nOver generation.".format(
str(row + 1)))
return False
except ValueError:
QtWidgets.QMessageBox.critical(
self, "error",
"in row: {}\nRound number error.".format(
str(row + 1)))
return False
# 第二列，单纯保存一下名字就可以了
elif col == 1:
the_name = self.script_table_widget.item(row, col).text()
SCRIPT.setAttribute("funcName", the_name)
# 第三列，需要分离出文件名与文件所在路径
elif col == 2:
the_path = self.script_table_widget.item(row, col).text()
module_name = the_path.split('/')[-1].split('.')[0]
SCRIPT.setAttribute("moduleName", module_name)
script_path = '/'.join(the_path.split('/')[0:-1])
SCRIPT.setAttribute("path", script_path)
# 其他未知错误
else:
QtWidgets.QMessageBox.critical(
self, "error",
"in row: {}\nRound number error.".format(str(row + 1)))
SCRIPTS.appendChild(SCRIPT)
# 保存
write_xml(save_path + '/' + file_name, doc)
self.service_msg_log_text.append(
str(datetime.now()) + ': ' + "Setting scripts succeed." +
"({})".format(str(self.script_table_widget.rowCount())))
return True
def slot_return_from(self, current):
# 一个迭代的仿真结束了，需要判断一下仿真是否需要继承数据。
self.current_generation = current
# print("in widget, current_generation:{}".format(self.current_generation))
self.exe_progress_bar.setValue(self.current_generation /
external_func.round_number * 100)
if current == external_func.round_number:
self.slot_btn_pause()
self.end_moment = datetime.now()
self.service_msg_log_text.append(
str(self.end_moment) + ": Simulation task completed.")
record_dom = read_xml(self.record_dir_path_edit.text() +
"/Simulation_Record.xml")
record_dom_root = record_dom.getElementsByTagName("Result")[0]
record_dom_root.setAttribute("EndMoment", str(self.end_moment))
record_dom_root.setAttribute(
"TimeConsuming", str(self.end_moment - self.start_moment))
write_xml(
self.record_dir_path_edit.text() + "/Simulation_Record.xml",
record_dom)
if current % int(self.step_size_Edit.text()) == 0:
self.MyThread.flag = False
save_member_round_record(self.record_dir_path_edit.text(), current,
self.global_dict,
len(self.generation_Edit.text()))
save_global_attribute_record(self.record_dir_path_edit.text(),
current, self.global_dict)
self.MyThread.flag = True
def save_member_round_record(record_path, round_number, global_dict, width):
"""
保存每一轮仿真所有成员的信息
:param record_path: 仿真记录存储路径
:param round_number: 第几回合
:param global_dict: 保存了全局所有变量的字典
:param width: 一共仿真的轮数
:return: noreturn
"""
# 整理一下所有的成员
def save_network_round_record():
root = record_detail_dom.getElementsByTagName("RecordDetail")[0]
networks_label = record_detail_dom.createElement("network")
for network_id, network_obj in members.network_dict.items():
network_label = record_detail_dom.createElement("networkStructure")
network_label.setAttribute("networkID", network_id)
the_nodes = list(network_obj.nodes)
for one_node_id in the_nodes:
node_label = record_detail_dom.createElement("node")
node_label.setAttribute("memberID", one_node_id)
node_dict = dict(network_obj[one_node_id])
for link_node_id, edge_dict in node_dict.items():
link_node_label = record_detail_dom.createElement(
"link_node")
link_node_label.setAttribute("memberID", link_node_id)
for edge_key, edge_value in edge_dict.items():
link_node_label.setAttribute(edge_key, str(edge_value))
node_label.appendChild(link_node_label)
network_label.appendChild(node_label)
networks_label.appendChild(network_label)
root.appendChild(networks_label)
member_dict = {
'primitives': members.primitive_dict,
'collectives': members.collective_dict,
'advisers': members.adviser_dict,
'monitors': members.monitorMember_dict,
}
# 将整理得到的所有成员保存为符合xml文档的字符串
res = "<%s>" "%s" "</%s>" % ("RecordDetail", dict_to_xml_str(member_dict),
"RecordDetail")
# 将固定格式的字符串转化为dom对象
record_detail_dom = parseString(res)
root = record_detail_dom.getElementsByTagName("RecordDetail")[0]
root.setAttribute("round", str(round_number))
for v in external_func.global_attribute_dict.values():
root.setAttribute(v['aName'], str(global_dict[v['aName']]))
save_network_round_record()
write_xml(
record_path + "/" + 'Record_Detail_' + str(round_number).zfill(width) +
'.xml', record_detail_dom)
print("make record in round :{}".format(round_number))
def save_global_attribute_record(record_path, round_number, global_dict):
"""
保存全局属性记录
:param record_path:仿真记录保存路径
:param round_number: 第几轮仿真
:param global_dict: 保存所有变量的字典
:return: no return
"""
# 获取总览记录文件
record_dom = read_xml(record_path + "/" + "Simulation_Record.xml")
root = record_dom.getElementsByTagName("Result")[0]
round_record_dom = record_dom.createElement("Record")
for v in external_func.global_attribute_dict.values():
round_record_dom.setAttribute(v['aName'], str(global_dict[v['aName']]))
round_record_dom.setAttribute("round", str(round_number))
root.appendChild(round_record_dom)
write_xml(record_path + "/" + "Simulation_Record.xml", record_dom)
range(len(primitive_labels))):
primitive_label.setAttribute("能力向量", str(list(ability_matrix[:, idx])))
primitive_label.setAttribute("学习向量", str(list(learn_matrix[:, idx])))
primitive_label.setAttribute("质量向量", str(list(quality_matrix[:, idx])))
primitive_label.setAttribute("外部学习向量", str([0 for _ in range(dimension)]))
# 安排格局上的初始点
# 获取格局初始点
init_position_list = []
position_labels = member_dom.getElementsByTagName("position")
for position_label in position_labels:
position_type = position_label.getAttribute('type')
if position_type == "start":
init_position_list.append(position_label.getAttribute('pID'))
the_len = init_position_list.__len__()
for primitive_label in primitive_labels:
if the_len == 1:
primitive_label.setAttribute("init_position", init_position_list[0])
primitive_label.setAttribute("current_position", init_position_list[0])
elif the_len > 1:
primitive_label.setAttribute("init_position",
init_position_list[randint(0, the_len)])
else:
try:
pass
except ValueError:
raise ("pattern have no init position")
write_xml(r"ceMemberXml_C.xml", member_dom)
p2a_net_label.setAttribute("type", "p2a")
for arc in rel_p_a:
conn_info_label = dom.createElement("connectInfo")
conn_info_label.setAttribute("from", arc[0])
conn_info_label.setAttribute("to", arc[1])
conn_info_label.setAttribute("strength", str(random()))
p2a_net_label.appendChild(conn_info_label)
connet_label.appendChild(p2a_net_label)
# 设置p2m-net
m_labels = dom.getElementsByTagName("monitorMemberInfo")
mon_id_list = []
for m_label in m_labels:
mon_id_list.append(m_label.getAttribute("监控者ID"))
m_label.setAttribute("监控强度", str(random()))
rel_p_m = list(product(p_id_list, mon_id_list))
shuffle(rel_p_m)
rel_p_m = rel_p_m[:len(rel_p_m) // 4]
p2m_net_label = dom.createElement("networkStructure")
p2m_net_label.setAttribute("ID", "net-p2m")
p2m_net_label.setAttribute("type", "p2m")
for arc in rel_p_m:
conn_info_label = dom.createElement("connectInfo")
conn_info_label.setAttribute("from", arc[0])
conn_info_label.setAttribute("to", arc[1])
conn_info_label.setAttribute("strength", str(random()))
p2m_net_label.appendChild(conn_info_label)
connet_label.appendChild(p2m_net_label)
write_xml("ceMemberXml_C.xml", dom)
time_list = []
attr_mu_sigma_list = [[60, 10, 'earn_list'], [600, 100, 'time_list']]
for earn_mu, earn_sigma, i in attr_mu_sigma_list:
l, u = earn_mu - 2 * earn_sigma, earn_mu + 2 * earn_sigma
E = stats.truncnorm((l - earn_mu) / earn_sigma, (u - earn_mu) / earn_sigma,
loc=earn_mu,
scale=earn_sigma)
the_list = eval(i)
for j in list(E.rvs(task_num)):
the_list.append(j)
task_dom = read_xml("Task.xml")
tasks_label = task_dom.createElement("Tasks")
for i in range(task_matrix.shape[1]):
task_label = task_dom.createElement("task")
task_label.setAttribute("ID", "Task-" + str(i))
task_label.setAttribute("taskDetail", str(list(task_matrix[:, i])))
task_label.setAttribute("earn", str(earn_list[i]))
task_label.setAttribute("time_limit", str(time_list[i]))
tasks_label.appendChild(task_label)
for j in range(task_matrix.shape[0]):
tasks_label.setAttribute("dimension-{}-mu".format(j),
str(mu_sigma_list[j][0]))
tasks_label.setAttribute("dimension-{}-sigma".format(j),
str(mu_sigma_list[j][1]))
task_dom.appendChild(tasks_label)
write_xml("Task.xml", task_dom)