def modify_param(s_file_name, r_old_param, s_new_param):
"""修改文件中的参数。
:param s_file_name: 文件名
:param r_old_param: 需要修改的参数的定位正则表达式
:param s_new_param: 修改后的参数
"""
f = open(s_file_name, 'r')
s_file_content = f.read()
f.close()
# replace string using re module
if re.search(r_old_param, s_file_content) is None:
std_output('WARNING! Regex %s not found in %s' %
(r_old_param, s_file_name))
s_file_content = re.sub(r_old_param, s_new_param, s_file_content)
f = open(s_file_name, 'w')
f.write(s_file_content)
f.close()
def read_and_check_kinetic(kinetic_node, d_inp):
"""
读取输入文件中的kinetic部分。
kinetic部分支持下述关键词的读取：
1 START：在执行动力学接续计算时，从第几步开始。输入值需要是自然数。
2 END：在执行动力学计算时，最多执行到第几步。输入值需要是整数。
:param kinetic_node: xml文件的的节点
:param d_inp: 存储读取信息的字典。函数运行结束后，d_inp将添加下列键值对：
'KINETIC_START'：动力学接续计算从哪一步开始，最小为0，,默认值为0。
'KINETIC_END'：动力学计算在哪一步结束，默认值为-1。
负数表示执行到RMC输入卡中规定的最大时间步。
"""
for kinetic_child in kinetic_node:
if kinetic_child.tag.upper() == 'START':
d_inp[keys.KineticKeys.start] = int(kinetic_child.text)
if not is_natural_number(d_inp[keys.KineticKeys.start]):
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp[keys.KineticKeys.start],
kinetic_child.tag,
kinetic_node.tag))
exit(1)
elif kinetic_child.tag.upper() == 'END':
d_inp[keys.KineticKeys.end] = int(kinetic_child.text)
elif kinetic_child.tag.upper() == 'TOTAL_STEP_NUM':
d_inp[keys.KineticKeys.total_step_num] = int(kinetic_child.text)
else:
std_output('Read Input Error: '
'Unrecognized keyword %s in card %s!'
% (kinetic_child.tag, kinetic_node.tag))
exit(1)
# set default value
# 设置默认值
if keys.KineticKeys.start not in d_inp.keys():
d_inp[keys.KineticKeys.start] = 0
if keys.KineticKeys.end not in d_inp.keys():
d_inp[keys.KineticKeys.end] = -1
if keys.KineticKeys.end not in d_inp.keys():
std_output('Read Input Error: '
'\'total_step_num\' not defined in card %s!'
% kinetic_node.tag)
exit(1)
def read_and_check_couple(couple_node, d_inp):
"""
读取输入文件中的couple部分。
couple部分支持下述关键词的读取：
1 MAX_ITERATION：每个时间步上，最多迭代多少次，输入值需要是正整数。
:param couple_node: xml文件的的节点
:param d_inp: 存储读取信息的字典。函数运行结束后，d_inp将添加下列键值对：
'MAX_ITERATION'：最大迭代次数，默认值为1
"""
for couple_child in couple_node:
# 读取最大迭代次数
if couple_child.tag.upper() == 'MAX_ITERATION':
d_inp[keys.CoupleKeys.max_iteration] = int(couple_child.text)
if d_inp[keys.CoupleKeys.max_iteration] <= 0:
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp[keys.CoupleKeys.max_iteration],
couple_child.tag,
couple_node.tag))
exit(1)
# 耦合功率
elif couple_child.tag.upper() == 'POWER':
d_inp[keys.CoupleKeys.power] = float(couple_child.text)
if d_inp[keys.CoupleKeys.power] <= 0:
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp[keys.CoupleKeys.power],
couple_child.tag,
couple_node.tag))
exit(1)
else:
std_output('Read Input Error: '
'Unrecognized keyword %s in card %s!'
% (couple_child.tag, couple_node.tag))
exit(1)
# set default value
# 设置默认值
if keys.CoupleKeys.max_iteration not in d_inp.keys():
d_inp[keys.CoupleKeys.max_iteration] = 1
def read_and_check_calculation(calculation_node, d_inp):
"""
读取输入文件中的CALCULATION部分。
CALCULATION部分支持下述关键词的读取：
1 CALCULATION_MODE：可以输入KINETIC， STEADY_COUPLE或者DYNAMIC_COUPLE，
其它参数都是非法的;
2 OUTPUT_NAME：日志文件的名字，任意输入都是合法的;
3 PLATFORM：运算的平台，可以输入LINUX，WINDOWS，TIANHE，TANSUO和SHENWEI，
其它参数都是非法的。
4 WORKSAPCE：该脚本的工作目录，任意输入都是合法的。
5 STORAGE：所有结果的存放目录，任意输入都是合法的。
:param calculation_node: xml文件的的节点
:param d_inp: 存储读取信息的字典。函数运行结束后，d_inp将添加下列键值对：
'CALCULATION_MODE':计算模式，默认值为'KINETIC'
'OUTPUT_NAME':日志文件全名，默认值为'stdout'
'PLATFORM':运行平台，默认值为'LINUX'
'WORKSPACE'：脚本的绝对工作目录，默认值为用户执行脚本的目录下的
workspace文件夹；如果文件夹下包含main.py的话，
那么会强制改为默认目录。
'STORAGE'：所有结果的存放目录，默认值为
用户执行脚本的目录下的results文件夹。
"""
for calculation_child in calculation_node:
# 输出的日志文件的名字
if calculation_child.tag.upper() == 'OUTPUT_NAME':
d_inp[keys.output_name] = calculation_child.text
if not os.path.isabs(d_inp[keys.output_name]):
d_inp[keys.output_name] = os.path.join(os.getcwd(),
d_inp[keys.output_name])
# 程序的运行平台
elif calculation_child.tag.upper() == 'PLATFORM':
d_inp[keys.platform] = calculation_child.text.upper()
if d_inp[keys.platform] not in \
['LINUX', 'WINDOWS', 'TIANHE', 'TANSUO', 'SHENWEI']:
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp[keys.platform],
calculation_child.tag,
calculation_node.tag))
exit(1)
# 脚本的执行位置
elif calculation_child.tag.upper() == 'WORKSPACE':
d_inp[keys.workspace] = calculation_child.text
if not os.path.isabs(d_inp[keys.workspace]):
d_inp[keys.workspace] = os.path.join(os.getcwd(),
d_inp[keys.workspace])
if 'main.py' in os.listdir(d_inp[keys.workspace]):
std_output('WARNING! It\'s not recommended to set the '
'workspace as the current directory. The workspace'
' was changed to the \'workspace\' instead.')
d_inp[keys.workspace] = os.path.join(d_inp[keys.workspace],
'workspace')
# 结果的存储位置
elif calculation_child.tag.upper() == 'STORAGE':
d_inp[keys.storage] = calculation_child.text
if not os.path.isabs(d_inp[keys.storage]):
d_inp[keys.storage] = os.path.join(os.getcwd(),
d_inp[keys.storage])
else:
std_output('Read Input Error: '
'Unrecognized keyword %s in card %s!'
% (calculation_child.tag, calculation_node.tag))
exit(1)
# 设置默认值
if keys.output_name not in d_inp.keys():
d_inp[keys.output_name] = os.path.join(os.getcwd(), DEFAULT_LOG_NAME)
if keys.calculation_mode not in d_inp.keys():
d_inp[keys.calculation_mode] = 'KINETIC'
if keys.platform not in d_inp.keys():
d_inp[keys.platform] = 'LINUX'
if keys.workspace not in d_inp.keys():
d_inp[keys.workspace] = os.path.join(os.getcwd(),
'workspace')
if keys.storage not in d_inp.keys():
d_inp[keys.storage] = os.path.join(os.getcwd(), 'results')
def read_and_check_ctf(ctf_node, d_inp):
"""
读取输入文件中的CTF部分。
CTF部分支持下述关键词的读取：
1 EXECUTABLE_NAME：CTF二进制可执行文件的全名，任意输入都是合法的;
2 PROCESS_NUM：CTF并行计算的进程数（核数），输入值需要是正整数。
3 WORKSPACE：CTF的执行目录，任意输入都是合法的。
4 STORAGE：CTF的结果目录，任意输入都是合法的，但只有底层目录是有效的。
5 SIMULATE：是否使用模拟模式来运行CTF。
:param ctf_node: xml文件的的节点
:param d_inp: 存储读取信息的字典。函数运行结束后，d_inp将添加下列键值对：
'CTF_EXECUTABLE_NAME':CTF二进制可执行文件的全名，默认值为'cobratf'
'CTF_PROCESS_NUM':CTF并行计算的进程数，默认值为1
'CTF_WORKSPACE'：CTF程序运行的绝对目录，默认值是脚本执行目录下的
'run_ctf'文件夹
'CTF_STORAGE'：CTF程序的结果的目录，默认值是脚本执行目录下的
storage的'ctf'文件夹
'CTF_SIMULATE'：是否使用模拟模式来运行CTF。默认值为False。
"""
for ctf_child in ctf_node:
if ctf_child.tag.upper() == 'PROCESS_NUM':
d_inp[keys.CtfKeys.process_num] = int(ctf_child.text)
if d_inp[keys.CtfKeys.process_num] <= 0:
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp[keys.CtfKeys.process_num],
ctf_child.tag,
ctf_node.tag))
exit(1)
elif ctf_child.tag.upper() == 'EXECUTABLE_NAME':
d_inp[keys.CtfKeys.executable_name] = ctf_child.text
elif ctf_child.tag.upper() == 'WORKSPACE':
d_inp[keys.CtfKeys.workspace] = ctf_child.text
if not os.path.isabs(d_inp[keys.CtfKeys.workspace]):
d_inp[keys.CtfKeys.workspace] = \
os.path.join(d_inp[keys.workspace],
d_inp[keys.CtfKeys.workspace])
elif ctf_child.tag.upper() == 'STORAGE':
d_inp[keys.CtfKeys.storage] = \
os.path.join(d_inp[keys.storage],
os.path.basename(ctf_child.text))
elif ctf_child.tag.upper() == 'SIMULATE':
d_inp[keys.CtfKeys.simulate] = (ctf_child.text.upper() == 'TRUE')
else:
std_output('Read Input Error: '
'Unrecognized keyword %s in card %s!'
% (ctf_child.tag, ctf_node.tag))
exit(1)
# set default value
# 设置默认值
if keys.CtfKeys.process_num not in d_inp.keys():
d_inp[keys.CtfKeys.process_num] = 1
if keys.CtfKeys.executable_name not in d_inp.keys():
d_inp[keys.CtfKeys.executable_name] = 'cobratf'
if keys.CtfKeys.workspace not in d_inp.keys():
d_inp[keys.CtfKeys.workspace] = os.path.join(d_inp[keys.workspace],
'run_ctf')
if keys.CtfKeys.storage not in d_inp.keys():
d_inp[keys.CtfKeys.storage] = os.path.join(d_inp[keys.storage], 'ctf')
if keys.CtfKeys.simulate not in d_inp.keys():
d_inp[keys.CtfKeys.simulate] = False
def read_and_check_rmc(rmc_node, d_inp):
"""
读取输入文件中的RMC部分。
RMC部分支持下述关键词的读取：
1 INPUT_NAME：RMC输入卡文件的全名，任意输入都是合法的;
2 EXECUTABLE_NAME：RMC二进制可执行文件的全名，任意输入都是合法的;
3 PROCESS_NUM：RMC并行计算的进程数（核数），输入值需要是正整数。
4 WORKSPACE：RMC程序运行的位置，任意输入都是合法的。
5 STORAGE：RMC程序的结果的位置，任意输入都是合法的，但只有底层目录会生效。
6 SIMULATE：是否使用模拟模式来运行RMC。
:param rmc_node: xml文件的的节点
:param d_inp: 存储读取信息的字典。函数运行结束后，d_inp将添加下列键值对：
'RMC_INP_NAME':RMC输入卡文件的全名，默认值为'inp'
'RMC_EXECUTABLE_NAME':RMC二进制可执行文件的全名，默认值为'RMC'
'RMC_PROCESS_NUM':RMC并行计算的进程数，默认值为1
'RMC_WORKSPACE'：RMC程序运行的绝对位置，默认值为脚本执行目录下的
'run_rmc'文件夹
'RMC_STORAGE'：RMC结果的存储位置，默认值为脚本执行目录下的
storage的'rmc'文件夹
'RMC_SIMULATE'：是否使用模拟模式来运行RMC，默认值为False。
"""
for rmc_child in rmc_node:
# RMC输入卡文件的全名
if rmc_child.tag.upper() == 'INPUT_NAME':
d_inp[keys.RmcKeys.inp_name] = rmc_child.text
# RMC二进制可执行文件的全名
elif rmc_child.tag.upper() == 'EXECUTABLE_NAME':
d_inp[keys.RmcKeys.executable_name] = rmc_child.text
# RMC并行进程数
elif rmc_child.tag.upper() == 'PROCESS_NUM':
d_inp[keys.RmcKeys.process_num] = int(rmc_child.text)
if d_inp[keys.RmcKeys.process_num] <= 0:
std_output('Read Input Error: '
'invalid parameter %s in keyword %s in card %s!'
% (d_inp['RMC_PROCESS_NUM'],
rmc_child.tag,
rmc_node.tag))
exit(1)
# RMC的执行位置
elif rmc_child.tag.upper() == 'WORKSPACE':
d_inp[keys.RmcKeys.workspace] = rmc_child.text
# RMC的文件的存储位置
elif rmc_child.tag.upper() == 'STORAGE':
d_inp[keys.RmcKeys.storage] = rmc_child.text
# 是否模拟计算
elif rmc_child.tag.upper() == 'SIMULATE':
d_inp[keys.RmcKeys.simulate] = (rmc_child.text.upper() == 'TRUE')
else:
std_output('Read Input Error: '
'Unrecognized keyword %s in card %s!'
% (rmc_child.tag, rmc_node.tag))
exit(1)
# 设置默认值
if keys.RmcKeys.inp_name not in d_inp.keys():
d_inp[keys.RmcKeys.inp_name] = 'inp'
if keys.RmcKeys.executable_name not in d_inp.keys():
d_inp[keys.RmcKeys.executable_name] = 'RMC'
if keys.RmcKeys.process_num not in d_inp.keys():
d_inp[keys.RmcKeys.process_num] = 1
if keys.RmcKeys.workspace not in d_inp.keys():
d_inp[keys.RmcKeys.workspace] = os.path.join(d_inp[keys.workspace],
'run_rmc')
if keys.RmcKeys.storage not in d_inp.keys():
d_inp[keys.RmcKeys.storage] = os.path.join(d_inp[keys.storage], 'rmc')
if keys.RmcKeys.simulate not in d_inp.keys():
d_inp[keys.RmcKeys.simulate] = False