def get_itargets(targets, dpath, dctc):
'''
get individual targets
'''
# Targets?
if (len(targets) == 0) or ("*" in targets): targets = dpath.keys()
# generate list of individual targets
itargets = []
for target in targets:
ctc, itc = PN.name2data(target)
# check ctc
if ctc not in dctc.keys():
fncs.print_string("* '%s' not in '%s'" % (target, PN.IFILE1), 3)
print("")
continue
if ctc not in dpath.keys():
fncs.print_string("* '%s' not in '%s'" % (target, PN.IFILE3), 3)
print("")
continue
# list of itcs for the ctc
itclist = [itc_i for itc_i, weight_i in dctc[ctc]._itcs]
# add itc
if itc is None:
itargets += [
PN.struckey(ctc, itc) for itc, weight in dctc[ctc]._itcs
]
elif itc in itclist:
itargets += [PN.struckey(ctc, itc)]
return sorted(itargets)
def obtain_cvt(dMols,
points,
VadiSpl,
temps,
pathvars,
si=-float("inf"),
sj=+float("inf"),
dcfs={}):
print
print " Calculating CVT variational coefficient..."
print
useics = pathvars._useics
if len(temps) == 0: raise Exc.NoTemps(Exception)
# Only points between si and sj
points = [pp for pp in points if si <= dMols[pp][0] <= sj]
lcvt_s, lcvt_gamma, gibbs_matrix, gibbsTS, lnew = cv.get_cvt(
dMols, points, VadiSpl, temps, useics)
# print gibbs
svals = [dMols[point][0] for point in points]
fncs.print_string(
PS.scvt_gibbs(svals, temps, gibbs_matrix.copy(), pathvars, gibbsTS), 8)
# print cvt coefs
fncs.print_string(PS.scvt_coefs(lcvt_s, lcvt_gamma, temps), 8)
# save data
dcfs["cvt"] = lcvt_gamma
return dcfs, lcvt_s, gibbs_matrix, lnew
def dctc_from_DIR1(gtsfiles):
# list of gts files
print(" - File '%s' does not exist but '%s' is not empty!" %
(PN.IFILE1, PN.DIR1))
print("")
# classify gts files according to ctc
dctc = {}
for gtsfile in gtsfiles:
gts_name = gtsname(gtsfile, "name")
gts_full = gtsname(gtsfile, "full")
ctc, itc = gts_name.split(".")[0:2]
dctc[ctc] = dctc.get(ctc, []) + [gts_full]
# generate real dctc
print(" number of structures: %i" % len(dctc.keys()))
print("")
ml = max([len(key) for key in dctc.keys()] + [1])
for ctc, gtsfiles in dctc.items():
print(" * %%-%is (num gts files: %%2i)" % ml %
(ctc, len(gtsfiles)))
CTC = ClusterConf(ctc)
status, string = CTC.set_from_gtsfiles(gtsfiles)
if status == -1:
print(" INCONSISTENCES!")
print_string(string, 9)
answer = input(" Remove gts files (y/N)?")
if answer.strip().lower() in ["y", "yes"]:
for gts in gtsfiles:
os.remove(gts)
else:
raise Exc.ABORTED
dctc[ctc] = CTC
print("")
return dctc
def print_summary(targets, LINES):
# Print lines for KMC
string = ""
string += "=================\n"
string += " FITTING SUMMARY \n"
string += "=================\n"
string += "\n"
for X in METHODS:
bloque_X = ""
for anatype in [1, 2, 3, 4, 5]:
bloque_at = ""
for rcname in targets:
for direc in "fw,bw".split(","):
key = (anatype, X, rcname, direc)
line = LINES.get(key, None)
if line is None: continue
bloque_at += line
#bloque_at += line.split("#")[0]+"\n"
if bloque_at == "": continue
bloque_X += bloque_at + "\n"
if bloque_X == "": continue
# add to string
string += "%s\n" % PS.KEYNICE[X]
string += "\n" + bloque_X + "\n"
print_string(string, NINIT)
def check_ctc(targets, dctc):
updated = []
for ctc in targets:
if ctc not in dctc.keys():
print_string(
"Selected target (%s) not found as a STRUC. Skipped!" % ctc, 2)
print("")
continue
updated.append(ctc)
return updated
def get_path_sctconv(itarget, gtsTS, pathvars, tsoftware, ltemp, TMP,
plotfile):
# assert no DLEVEL will be done (just in case)
pathvars._dlevel = None
# go ahead
convlist_sct = []
convlist_lim = []
for step in range(pathvars._sctmns + 2):
if step == 0: decrease = True
else: decrease = False
tcommon, drst, pathvars = calc_mep(itarget, gtsTS, pathvars, tsoftware,
TMP, decrease)
dcfs, pathvars = calc_coefs(itarget, tcommon, drst, pathvars, ltemp,
plotfile)
# expand data
lbw, lfw, sbw, sfw, Ebw, Efw = sd.rstlimits(drst)
SCT = dcfs["sct"]
del drst
# Save data only for lower temperature
convlist_sct.append(SCT[0])
convlist_lim.append((sbw, sfw))
# print convergence table
fncs.print_string(
PS.ssct_convergence(convlist_sct, convlist_lim, pathvars._scterr),
4)
# Check convergence
if len(convlist_sct) > 1:
SCT_a = convlist_sct[-1]
SCT_b = convlist_sct[-2]
dif100 = 100 * abs(SCT_a - SCT_b) / SCT_a
if dif100 < pathvars._scterr: break
# last step and not converged
if step + 1 == pathvars._sctmns + 2:
print " WARNING: SCT has not converged but 'sctmns' was reached!"
print
break
# increase variables sbw and sfw
sbw1, sfw1 = pathvars._sbw, pathvars._sfw
pathvars.increase_svals(Ebw, Efw)
sbw2, sfw2 = pathvars._sbw, pathvars._sfw
if abs(sbw1 - sbw2) < EPS_MEPS and abs(sfw1 - sfw2) < EPS_MEPS:
print " WARNING: MEP cannot be increased and SCT is not converged!"
print " Maybe epse and epsg criteria should be modified..."
print
break
else:
print " MEP will be increased for SCT convergence:"
print
print " sbw: %+8.4f --> %+8.4f bohr" % (sbw1, sbw2)
print " sfw: %+8.4f --> %+8.4f bohr" % (sfw1, sfw2)
print
print " =================================================="
print
return dcfs
def calc_mep(itarget, gtsTS, pathvars, tsoftware, TMP, decrease=False):
'''
if decrease = True, MEP is reduced hsteps steps
'''
# data in name
ctc, itc = PN.name2data(itarget)
# calculate path
tcommon, drst, pathvars = obtain_mep(itarget, gtsTS, pathvars, tsoftware,
TMP)
# decrease mep??
if decrease:
sbw1, sfw1 = pathvars._sbw, pathvars._sfw
pathvars.decrease_svals()
sbw2, sfw2 = pathvars._sbw, pathvars._sfw
print " MEP will be reduced to check SCT convergence:"
print
print " sbw: %+8.4f --> %+8.4f bohr" % (sbw1, sbw2)
print " sfw: %+8.4f --> %+8.4f bohr" % (sfw1, sfw2)
print
drst = {
label: data
for label, data in drst.items()
if in_interval(data[0], sbw2, sfw2)
}
# DLEVEL??
if pathvars._dlevel is not None:
print " Applying Dual-Level..."
print
dlevel_xy = [(find_label_in_rst(x, drst)[0], y)
for x, y in pathvars._dlevel.items()]
dlevel_xy = [(x, y) for x, y in dlevel_xy if x is not None]
# Print points (sorted by s value)
dummy = [(drst[xx][0], idx) for idx, (xx, yy) in enumerate(dlevel_xy)]
dummy.sort()
for s_i, idx_i in dummy:
xx_i, yy_i = dlevel_xy[idx_i]
print " %+8.4f bohr (%-6s) --> %.7f hartree" % (
s_i, xx_i, yy_i)
print
# interpolation
drst, points, xx, yyll, yyhl = ispe.ispe(tcommon,
drst,
dlevel_xy,
tension=0.0)
tdleveldata = (points, xx, yyll, yyhl)
# table new values
fncs.print_string(
PS.smep_tableDLEVEL(drst, tdleveldata, pathvars._eref), 4)
else:
# Print table
fncs.print_string(PS.smep_table(drst, pathvars._eref), 4)
return tcommon, drst, pathvars
def obtain_cag(Vadi, ltemp, lscvt=None, dcfs={}):
print
print " Calculating CAG coefficient..."
print
dE_cagtst, cagtst = cag.calc_cag(ltemp, Vadi)
dcfs["cagtst"] = cagtst
if lscvt is not None:
dE_cagcvt, cagcvt = cag.calc_cag(ltemp, Vadi, lscvt)
dcfs["cagcvt"] = cagcvt
else:
dE_cagcvt = None
cagcvt = None
fncs.print_string(
PS.scag_table(ltemp, dE_cagtst, cagtst, dE_cagcvt, cagcvt), 8)
return dcfs
def obtain_cag(Vadi, ltemp, E0, VAG, lscvt=None, dcfs={}):
print("")
fncs.print_string("Calculating CAG coefficient...", 4)
print("")
# calculate CAGTST
dE_cagtst, cagtst = cag.calc_cag(ltemp, Vadi)
# calculate CAGCVT
if lscvt is not None: dE_cagcvt, cagcvt = cag.calc_cag(ltemp, Vadi, lscvt)
else: dE_cagcvt, cagcvt = None, None
# In case E0 > VAG
if E0 >= VAG:
cagtst = list([1.0 for T in ltemp])
if cagcvt is not None: cagcvt = list([1.0 for T in ltemp])
# print data
fncs.print_string(
PS.scag_table(ltemp, dE_cagtst, cagtst, dE_cagcvt, cagcvt), 8)
# save in dict and return
if cagtst is not None: dcfs["cagtst"] = cagtst
if cagcvt is not None: dcfs["cagcvt"] = cagcvt
return dcfs
def main(idata,status,case):
stat2check = [2,5]
mustexist = []
tocreate = []
#-------------------------------------------------------#
# Read Pilgrim input files, check file/folder status #
# and expand tuple 'case' #
#-------------------------------------------------------#
# expand data
(dctc,dimasses), ltemp, dpath, (dtesLL,dtesHL), dchem, tkmc, ddlevel = idata
# status ok?
fstatus = status_check(status,stat2check)
if fstatus == -1: exit()
# existency of folders
fstatus = ffchecking(mustexist,tocreate)
if fstatus == -1: exit()
# expand case
(dof,hlf,plotfile),dlevel,software = case
#-------------------------------------------------------#
# read dofs
dall, ltemp = RW.read_alldata(dof)
# get saved reactions
print_string(PS.skies_summary(dchem,dall),5)
# Ask user which reactions
count = 0
while True:
# Ask user for reactions
bool_end,bool_cont,reaction1,reaction2 = ask_for_reactions(dchem)
print("")
print("")
if bool_end : break
if bool_cont: continue
kies_from_pair_of_reactions(reaction1,reaction2,ltemp,dchem,dctc,dall)
def kies_from_pair_of_reactions(reactionH,reactionD,ltemp,dchem,dctc,dall):
# a) Deal with reaction without isotopes
rcnameH, dirH = reactionH.split(".")[0:2]
RsH,TSH,PsH = dchem[rcnameH]
chemreacH = ChemReaction(rcnameH,RsH,TSH,PsH,ltemp,dctc)
chemreacH.external_data(dall)
# b) Deal with reaction with isotopes
rcnameD, dirD = reactionD.split(".")[0:2]
RsD,TSD,PsD = dchem[rcnameD]
chemreacD = ChemReaction(rcnameD,RsD,TSD,PsD,ltemp,dctc)
chemreacD.external_data(dall)
# c) chi_i's, transmission coefficients, anharmonicity, rate constants
chemreacH.obtain_pfns()
chemreacD.obtain_pfns()
chemreacH.calculate_transcoeffs()
chemreacD.calculate_transcoeffs()
chemreacH.calculate_anharmonicity()
chemreacD.calculate_anharmonicity()
chemreacH.calculate_rateconstants()
chemreacD.calculate_rateconstants()
#lXH = chemreacH._tschi.keys()
#lXD = chemreacD._tschi.keys()
# d) translational, rovibrational and torsional KIES
print_string(PS.skies_definitions(),5)
kies_tr,kies_rv,kies_el,kies_tor = contrib_tr_rv_el_tor(chemreacH,chemreacD,dirH,dirD)
print_string(PS.skies_basiccontris(ltemp,kies_tr,kies_rv,kies_tor),5)
# e) vtun, total and total with anharmonicity
kies_vtun, kies_tot = contrib_vtun_tot(chemreacH,chemreacD,dirH,dirD,kies_tr,kies_rv,kies_tor)
print_string(PS.skies_vtun_tot(ltemp,kies_vtun,kies_tot),5)
# f) individual contributions
ikies_rv, ikies_vtun = contrib_ind_rv_vtun(chemreacH,chemreacD,dirH,dirD,kies_rv)
pjh, pjd = contrib_pjd_pjh(chemreacH,chemreacD,dirH,dirD,\
kies_rv,kies_vtun,ikies_rv,ikies_vtun)
totkies_j,totkiest_j = contrib_totikies(pjh,pjd,kies_tot)
print_string(PS.skies_indkies(ltemp,ikies_rv,ikies_vtun,pjh,pjd,totkies_j,totkiest_j),5)
def factors_from_TS(TS, V1TS, QTS, ltemp, dctc, dall):
# list of itcs
ctc, itc = PN.name2data(TS)
if itc is None: itcs = dctc[ctc]._itcs
else: itcs = [(itc, 1)]
# get TST ratios
tst_ratios = get_TSratios(ctc, itcs, V1TS, QTS, ltemp, dall)
# print TST ratios
print_string(PS.srcons_tstratios(ltemp, tst_ratios), 7)
# get total correction factors
corrfactors = get_corrfactors(ltemp, ctc, itcs, dall, tst_ratios)
# print correction factors
print_string(PS.string_corrfactors(ltemp, corrfactors), 7)
# print VTST contributions
print_string(PS.srcons_vtstratios(ltemp, tst_ratios, corrfactors), 7)
return tst_ratios, corrfactors
def execute_pfn(itargets, dchem, idata, status, case):
reactions = set([])
for target in itargets:
ctc1, itc1 = PN.name2data(target)
the_reaction = None
for reaction, (Rs, TS, Ps) in dchem.items():
try:
ctc2, itc2 = PN.name2data(TS)
except:
continue
if ctc1 == ctc2:
the_reaction = reaction
if itc1 == itc2: break
if the_reaction is not None: reactions.add(the_reaction)
if len(reactions) == 0: return
reactions = sorted(list(reactions))
fncs.print_string(
"The selected transitions states are involved in defined reactions!",
3)
pfn_targets = set([])
for reaction in reactions:
fncs.print_string("* %s" % reaction, 6)
Rs, TS, Ps = dchem[reaction]
for xx in Rs + [TS] + Ps:
pfn_targets.add(PN.name2data(xx)[0])
if len(pfn_targets) == 0: return
pfn_targets = sorted(list(pfn_targets))
print("")
import opt_pfn as pfn
fncs.print_string("Calculating partition functions for the next targets:",
3)
for target in pfn_targets:
fncs.print_string("* %s" % target, 6)
print("")
pfn.main(idata, status, case, targets=pfn_targets)
def obtain_adipot(tcommon, drst, pathvars):
print
print " Calculating adiabatic potential..."
print
ics = pathvars.get_ics()
if pathvars._useics == "yes" and (ics is None or len(ics) == 0):
raise Exc.NoICS(Exception)
# calculate adiabatic potential
idata = (tcommon, drst, pathvars._eref, ics, pathvars._useics,
pathvars._lowfq, pathvars._freqscal)
dMols, ccVadi, icVadi, tuple_cc, tuple_ic, listV0 = ap.path2vadi(*idata)
# expand tuples
data_x, lcc_frqs, lcc_tzpe = tuple_cc
data_x, lic_frqs, lic_tzpe = tuple_ic
# check data
fncs.print_string(PS.sadipot_ics(ics, pathvars._useics), 8)
if pathvars._useics == "yes":
ok1 = ap.ccvsic_checknfreqs(lcc_frqs, lic_frqs)
ok2 = ap.ccvsic_checkts(data_x, lcc_frqs, lic_frqs)
ok3 = ap.ccvsic_checkzpe(lcc_tzpe, lic_tzpe)
checks = (ok1, ok2, ok3)
fncs.print_string(PS.sadipot_checks(checks), 8)
# select spline
if not ok1 or not ok2: Vadi, pathvars._useics = ccVadi, "no"
elif pathvars._useics == "yes": Vadi, pathvars._useics = icVadi, "yes"
else: Vadi, pathvars._useics = ccVadi, "no"
else:
Vadi, pathvars._useics = ccVadi, "no"
# setup spline
Vadi.setup()
data4print = (Vadi.xx(), Vadi.yy(), Vadi._sAG, Vadi._VAG, listV0, lcc_tzpe,
lic_tzpe, pathvars._eref)
fncs.print_string(PS.sadipot_table(*data4print), 8)
# print freqs
print " Vibrational frequencies summary: cc (ic) [in cm^-1]:"
fncs.print_string(PS.sadipot_freqs(Vadi.xx(), lcc_frqs, lic_frqs), 8)
return dMols, Vadi, pathvars
def main(idata, status):
stat2check = []
mustexist = []
tocreate = []
#-------------------------------------------------------#
# Read Pilgrim input files and check file/folder status #
#-------------------------------------------------------#
# expand data
(dctc, dimasses), ltemp, dpath, (dtesLL,
dtesHL), dchem, dkmc, ddlevel = idata
# status ok?
fstatus = status_check(status, [])
if fstatus == -1: exit()
# special warning
if status[0] == -1:
print(" WARNING! '%s' file not found." % PN.IFILE1)
print(" In order to generate it, run")
print(" pilgrim --gather")
# existency of folders
fstatus = ffchecking(mustexist=[], tocreate=[])
if fstatus == -1: exit()
#-------------------------------------------------------#
# print menu
print_string(MENU, 1)
# setup dpath
for ctc in dpath.keys():
dpath[ctc].setup1()
dpath[ctc].setup2()
# interactive menu
dbool = {}
while True:
set_completer(1)
line = input(ILINE1).split()
if len(line) == 0: continue
command = line[0].lower()
try:
var = line[1].lower()
except:
var = None
try:
val = line[2:]
except:
val = None
# update list of transition states
lts = [ctc for ctc in dctc.keys() if dctc[ctc]._type == 1]
# user ask for help
if command == "help":
if var is None: print_string(MENU, 3)
elif var == "temp": print_string(HELP_temp, 6)
elif var == "path": print_string(HELP_path, 6)
elif var == "chem": print_string(HELP_chem, 6)
elif var == "kmc": print_string(HELP_kmc, 6)
elif var == "dlevel": print_string(HELP_dlevel, 6)
elif var == "isomass": print_string(HELP_isomass, 6)
elif var == "struc": print_string(HELP_struc, 6)
# user ask for list
elif command == "ls":
if var == "struc": ls_struc(dctc)
elif var == "temp": ls_temp(ltemp)
elif var == "path": ls_path(dpath)
elif var == "chem": ls_chem(dchem)
elif var == "kmc": ls_kmc(dkmc)
elif var == "dlevel": ls_dlevel(ddlevel)
elif var == "isomass": ls_isomass(dimasses)
else: continue
# add
elif command == "add":
if var == "temp": ltemp = add_temp(val, ltemp)
elif var == "path":
dpath, dtesLL = add_path(val, dpath, dctc, dtesLL, lts)
elif var == "chem":
dchem = add_chem(val, dchem)
elif var == "kmc":
dkmc = add_kmc(val, dkmc, dchem)
elif var == "dlevel":
ddlevel, dtesHL = add_dlevel(val, ddlevel, dctc, dtesHL)
elif var == "isomass":
dimasses = add_isomass(val, dimasses)
dbool[var] = True
# mod
elif command == "mod":
if var == "path":
dpath, dtesLL = add_path(val,
dpath,
dctc,
dtesLL,
lts,
mod=True)
elif var == "struc":
dctc = mod_struc(val, dctc, dimasses)
elif var == "kmc":
dkmc = mod_kmc(val, dkmc, dchem)
dbool[var] = True
# rm
elif command == "rm":
if var == "temp": ltemp = rm_temp(val, ltemp)
elif var == "path": dpath = rm_path(val, dpath)
elif var == "chem": dchem = rm_chem(val, dchem)
elif var == "dlevel": ddlevel = rm_dlevel(val, ddlevel)
elif var == "struc": dctc = rm_struc(val, dctc)
elif var == "isomass": dimasses = rm_isomass(val, dimasses)
elif var == "kmc": dkmc = rm_kmc(val, dkmc)
dbool[var] = True
# user ask for finishing
elif command in END:
if dbool != {}:
print("")
print(" (Re)Writing files:")
if dbool.get("isomass", False) or dbool.get("struc", False):
print(" %s" % PN.IFILE1)
RW.write_ctc(dctc, dimasses)
if dbool.get("temp", False):
print(" %s" % PN.IFILE2)
RW.write_temp(ltemp)
if dbool.get("path", False):
print(" %s" % PN.IFILE3)
RW.write_path(dpath)
if dbool.get("path", False) or dbool.get("dlevel", False):
print(" %s" % PN.IFILE4)
RW.write_tes(dtesLL, dtesHL)
if dbool.get("chem", False):
print(" %s" % PN.IFILE5)
RW.write_chem(dchem)
if dbool.get("kmc", False):
print(" %s" % PN.IFILE6)
RW.write_kmc(dkmc)
if dbool.get("dlevel", False):
print(" %s" % PN.IFILE7)
RW.write_dlevel(ddlevel)
print("")
break
# user ask for nothing
else:
continue
def basicinfo_reaction(Rs, TS, Ps, dctc, dimasses):
# Equation of the reaction
string = ""
string += " equation : "
string += " + ".join(Rs)
string += " --> "
if TS is not None: string += TS
string += " --> "
string += " + ".join(Ps)
string += "\n\n"
# Identify reactants, transition state and products
string += " reactant(s) : %s\n" % (" + ".join(Rs))
if TS is not None: string += " transition state: %s\n" % TS
string += " product(s) : %s\n" % (" + ".join(Ps))
string += "\n"
if len(Rs) == 2 and Rs[0] == Rs[1]:
string += " The two reactants are equal.\n"
string += " Forward rate constants will be multiplied by 2\n"
string += "\n"
if len(Ps) == 2 and Ps[0] == Ps[1]:
string += " The two products are equal.\n"
string += " Backward rate constants will be multiplied by 2\n"
string += "\n"
print_string(string, 5)
# get length of name
not_in_dctc = []
data = []
ml = 4
for target in Rs + [TS] + Ps:
if target is None: continue
# ctc and itc name
if "." in target: ctc, itc = target.split(".")
else: ctc, itc = target, None
# list of itcs
if itc is None:
if ctc in dctc.keys(): itcs = dctc[ctc]._itcs
else: itcs = None
else: itcs = [(itc, 1)]
# save data?
if itcs is None:
not_in_dctc.append(target)
continue
data.append((target, itcs))
if len(target) > ml: ml = len(target)
# anything not defined in dctc?
if len(not_in_dctc) != 0:
string = "The following compounds are not defined in '%s':\n" % PN.IFILE1
for target in not_in_dctc:
string += " * %s\n" % target
if target in Rs: Rs = []
if target in Ps: Ps = []
print_string(string, 7)
# head of table and division line
head = (" %%%is | conformer | weight" % ml) % "Name"
division = "-" * len(head)
# listing conformers and weights
string = "Conformational flexibility:\n"
string += "\n"
string += " " + division + "\n"
string += " " + head + "\n"
string += " " + division + "\n"
for target, itcs in data:
for idx, (itc, weight) in enumerate(itcs):
if idx == 0:
string += " " + (" %%%is " %
ml) % target + "| %3s | %2i \n" % (
itc, weight)
else:
string += " " + (
" %%%is " % ml) % "" + "| %3s | %2i \n" % (itc,
weight)
string += " " + division + "\n"
print_string(string, 7)
# Conservation of mass/ch
string, conserved = check_balance(dctc, dimasses, Rs, TS, Ps)
print_string(string, 7)
return conserved, not_in_dctc
for unkn in unknown:
print " * %s" % unkn
print
# read dof
dall = RW.read_alldata(dof, ltemp)[0]
#--------------------------------#
# Calculations for each reaction #
#--------------------------------#
for rcname in targets:
# pof file
pof = PN.get_pof(dlevel, "rcons", rcname)
sys.stdout = Logger(pof, "w", True)
# print title
print_string(PS.title_rcons(rcname, pof), 3)
# get data
Rs, TS, Ps = dchem[rcname]
# Rs = Ps?
wfw, wbw = 1, 1
if len(Rs) == 2 and Rs[0] == Rs[1]: wfw *= 2
if len(Ps) == 2 and Ps[0] == Ps[1]: wbw *= 2
# basic info
allright, not_in_dctc = basicinfo_reaction(Rs, TS, Ps, dctc, dimasses)
if not allright: continue
# clean data
if len(set(not_in_dctc).intersection(Rs)) != 0: Rs = []
if len(set(not_in_dctc).intersection(Ps)) != 0: Ps = []
if TS in not_in_dctc: TS = None
nR = len(Rs)
nP = len(Ps)
def main():
date = time.strftime("%Y/%m/%d %H:%M")
t1 = time.time()
# Read user arguments
user_args = sys.argv[1:]
if len(user_args) == 0:
print PROGNAME
print AUTHORINFO
print_string(HELP_main,2)
return
dargs = classify_args(user_args)
# User asked for version
if "version" in dargs.keys():
print "Current version: %s"%VERSION
return
# User asked for help
elif "help" in dargs.keys():
print PROGNAME
print AUTHORINFO
if len(dargs["help"]) == 0 : print_string(HELP_main ,2)
if "gather" in dargs["help"]: print_string(HELP_gather,1)
if "input" in dargs["help"]: print_string(HELP_input ,1)
if "ics" in dargs["help"]: print_string(HELP_ics ,1)
if "pfn" in dargs["help"]: print_string(HELP_pfn ,1)
if "path" in dargs["help"]: print_string(HELP_path ,1)
if "hlcalc" in dargs["help"]: print_string(HELP_hlcalc,1)
if "rcons" in dargs["help"]: print_string(HELP_rcons ,1)
if "fit" in dargs["help"]: print_string(HELP_fit ,1)
if "kmc" in dargs["help"]: print_string(HELP_kmc ,1)
if "plot" in dargs["help"]: print_string(HELP_plot ,1)
return
# Print logo and current date
print PROGNAME
print AUTHORINFO
print
print " -----------------------------------------------------------"
print " Current date: %s"%date
print " -----------------------------------------------------------"
print
# check some arguments
dargs = check_ics(dargs)
software = check_sft(dargs)
dlevel = check_dlevel(dargs)
# --software used properly
if software is None:
print " Software option has to be followed by an argument!"
print
exit()
# Act according user argument
IN_OPTS = False
for option in "ls,gather,input,ics,pfn,path,hlcalc,rcons,kmc,fit,plot".split(","):
if option not in dargs.keys(): continue
IN_OPTS = True
# read input files and print table
idata, status, string = get_input_data()
print_string(string,nbs=3)
# data files according to case
datafiles,string = dlevel_to_files(dlevel)
if option in "pfn,path,hlcalc,rcons,kmc,fit,plot".split(","):
print_string(string,nbs=3)
case = (datafiles,dlevel,software)
# execute pilgrim with option
print " ==========================================================="
print " || EXECUTING PILGRIM WITH --%-6s ||"%option
print " ==========================================================="
print
if option == "ls" : gather.ls_struc(idata[0][0])
elif option == "gather": gather.main(idata,status )
elif option == "input" : inpmenu.main(idata,status )
elif option == "ics" : ics.main(idata,status,*dargs["ics" ] )
elif option == "pfn" : pfn.main(idata,status,case, dargs["pfn" ])
elif option == "path" : path.main(idata,status,case, dargs["path" ])
elif option == "hlcalc": hlcalc.main(idata,status,case, dargs["hlcalc"])
elif option == "rcons" : rcons.main(idata,status,case, dargs["rcons" ])
elif option == "kmc" : kmc.main(idata,status,case )
elif option == "fit" : fit.main(idata,status,case, dargs["fit" ])
elif option == "plot" : plot.main( case, dargs["plot" ])
print
print " ===========================================================\n"
break
# User asked for nothing. Print help!
if not IN_OPTS: print_string(HELP_main,2); return
# Print elapsed time
t2 = time.time()
timeline = "Total Elapsed Time: %5.1f %5s |"%time2human(t2-t1,"secs")
print " "+timeline
print " "+"-"*len(timeline)
#-------------------------------------------------------#
# expand data
(dctc, dimasses), ltemp, dpath, (dtesLL,
dtesHL), dchem, tkmc, ddlevel = idata
# status ok?
fstatus = status_check(status, stat2check)
if fstatus == -1: exit()
# existency of folders
fstatus = ffchecking(mustexist, tocreate)
if fstatus == -1: exit()
# expand case
(dof, hlf, plotfile), dlevel, software = case
#-------------------------------------------------------#
# print selected software
fncs.print_string("Selected software: %s" % software, 3)
print("")
# read high level file
if dlevel: dhighlvl = RW.read_highlevelfile(hlf)
else: dhighlvl = {}
# update targets
if targets == [] or targets == "*": targets = dpath.keys()
itargets = get_itargets(targets, dpath, dctc)
# Print targets
if len(itargets) != 0:
fncs.print_string("The paths will be calculated for:", 3)
for idx in range(0, len(itargets), 4):
fncs.print_string("%s" % (", ".join(itargets[idx:idx + 4])), 7)
def main():
cdate = time.strftime("%Y-%m-%d")
ctime = time.strftime("%H:%M:%S")
t1 = time.time()
# Read user arguments
user_args = sys.argv[1:]
if len(user_args) == 0:
print(PROGNAME)
print(PROGHEAD)
print(AUTHORINFO)
print_string(HELP_main, 2)
return
dargs = classify_args(user_args)
# User asked for version
if "version" in dargs.keys() or "-v" in user_args:
print("Current version: %s" % VERSION)
return
# User asked for help
elif "help" in dargs.keys():
print(PROGNAME)
print(PROGHEAD)
print(AUTHORINFO)
if len(dargs["help"]) == 0: print_string(HELP_main, 2)
if "gather" in dargs["help"]: print_string(HELP_gather, 1)
if "input" in dargs["help"]: print_string(HELP_input, 1)
if "ics" in dargs["help"]: print_string(HELP_ics, 1)
if "pfn" in dargs["help"]: print_string(HELP_pfn, 1)
if "path" in dargs["help"]: print_string(HELP_path, 1)
if "hlcalc" in dargs["help"]: print_string(HELP_hlcalc, 1)
if "rcons" in dargs["help"]: print_string(HELP_rcons, 1)
if "fit" in dargs["help"]: print_string(HELP_fit, 1)
if "kmc" in dargs["help"]: print_string(HELP_kmc, 1)
if "plot" in dargs["help"]: print_string(HELP_plot, 1)
if "kies" in dargs["help"]: print_string(HELP_kies, 1)
return
# Print logo and current date
string_head = PROGNAME + "\n" + PROGHEAD + "\n" + AUTHORINFO + "\n" + "\n"
string_head += " -----------------------------------------------------------\n"
string_head += exe_info()
string_head += " -----------------------------------------------------------\n\n"
print(string_head)
# check some arguments
dargs = check_ics(dargs)
software = check_sft(dargs)
dlevel = check_dlevel(dargs)
# --software used properly
if software is None:
print(" Software option has to be followed by an argument!")
print("")
exit()
# Act according user argument
IN_OPTS = False
for option in "ls,gather,input,ics,pfn,path,hlcalc,rcons,kmc,fit,plot,kies".split(
","):
if option not in dargs.keys(): continue
IN_OPTS = True
# read input files and print table
idata, status, string = get_input_data()
print_string(string, nbs=3)
# data files according to case
datafiles, string = dlevel_to_files(dlevel)
if option in "pfn,path,hlcalc,rcons,kmc,fit,plot".split(","):
print_string(string, nbs=3)
case = (datafiles, dlevel, software)
# execute pilgrim with option
print(" ===========================================================")
print(" || EXECUTING PILGRIM WITH --%-6s ||" %
option)
print(" ===========================================================")
print("")
if option == "ls": gather.ls_struc(idata[0][0])
elif option == "gather": gather.main(idata, status)
elif option == "input": inpmenu.main(idata, status)
elif option == "ics": ics.main(idata, status, *dargs["ics"])
elif option == "pfn": pfn.main(idata, status, case, dargs["pfn"])
elif option == "path": path.main(idata, status, case, dargs["path"])
elif option == "hlcalc":
hlcalc.main(idata, status, case, dargs["hlcalc"])
elif option == "rcons":
rcons.main(idata, status, case, dargs["rcons"])
print(" Pilgrim output file: %s"%pof)
print("")
sys.stdout = Logger(pof,"w",True)
sys.stdout.writeinfile(PS.init_txt())
# expand KMC tuple
ipops,rcs,psteps,volume,timeunits,excess = dkmc[target]
valid_tu = "fs,ps,mcs,ms,s,min,hr".split(",")
if timeunits not in valid_tu: timeunits = "ps"
# reactivo limitante
try : POP0 = min([ipop for species,ipop in sorted(ipops.items()) if ipop != 0.0])
except: POP0 = 0
print_string(PS.skmc_init(ipops,POP0,excess,rcs,psteps,volume,timeunits,dof),5)
# continue?
if POP0 == 0:
print(" All initial populations are zero...")
print("")
return
if rcs == {}:
print(" No reactions considered in %s"%PN.IFILE6)
print("")
return
# read dof
dall = RW.read_alldata(dof,ltemp)[0]
# perform KMC for each temperature
def obtain_adipot(tcommon, drst, pathvars, symmetry):
print("")
fncs.print_string("Calculating adiabatic potential...", 4)
print()
ics = pathvars.get_ics()
icsbw = pathvars._icsbw
icsfw = pathvars._icsfw
if pathvars._useics == "yes" and (ics is None or len(ics) == 0):
raise Exc.NoICS(Exception)
# calculate adiabatic potential
idata = (tcommon, drst, pathvars._eref, ics, pathvars._useics,
pathvars._lowfq, pathvars._freqscal, icsbw, icsfw, symmetry)
dMols, ccVadi, icVadi, tuple_cc, tuple_ic, listV0 = ap.path2vadi(*idata)
# expand tuples
data_x, lcc_frqs, lcc_tzpe = tuple_cc
data_x, lic_frqs, lic_tzpe = tuple_ic
# check data
fncs.print_string(PS.sadipot_ics(ics, pathvars._useics, icsbw, icsfw), 8)
if pathvars._useics == "yes":
ok1 = ap.ccvsic_checknfreqs(lcc_frqs, lic_frqs)
ok2 = ap.ccvsic_checkts(data_x, lcc_frqs, lic_frqs)
ok3 = ap.ccvsic_checkzpe(lcc_tzpe, lic_tzpe)
checks = (ok1, ok2, ok3)
# select spline
if not ok1 or not ok2: Vadi, pathvars._useics = ccVadi, "no"
elif pathvars._useics == "yes": Vadi, pathvars._useics = icVadi, "yes"
else: Vadi, pathvars._useics = ccVadi, "no"
else:
ok1, ok2, ok3 = True, True, True
Vadi, pathvars._useics = ccVadi, "no"
# Any imag freq along the MEP?
if pathvars._useics == "yes": lfqs = list(lic_frqs)
else: lfqs = list(lcc_frqs)
nfreqs = min([len(xx) for xx in lcc_frqs])
allfqreal = True
for lfq in lfqs:
if len(lfq) > nfreqs: lfq = lfq[1:]
if True in [fq < 0.0 for fq in lfq]: allfqreal = False
del lfqs
# print checks
fncs.print_string(
PS.sadipot_checks(ok1, ok2, ok3, pathvars._useics, allfqreal), 8)
# setup spline
Vadi.setup()
data4print = (Vadi.xx(), Vadi.yy(), Vadi._sAG, Vadi._VAG, listV0, lcc_tzpe,
lic_tzpe, pathvars._eref)
fncs.print_string(PS.sadipot_table(*data4print), 8)
# print freqs
fncs.print_string("- Vibrational frequencies summary: cc (ic) [in cm^-1]:",
8)
print("")
fncs.print_string(PS.sadipot_freqs(Vadi.xx(), lcc_frqs, lic_frqs), 8)
return dMols, Vadi, pathvars
def obtain_mep(target, gtsTS, pathvars, tsoftware, TMP):
ctc, itc = PN.name2data(target)
# create folder now and not in the parallel process
if not os.path.exists(TMP):
try:
os.mkdir(TMP)
except:
pass
# Files
rstfile = PN.get_rst(ctc, itc)
xyzfile = PN.get_rstxyz(ctc, itc)
# print
software, tes = tsoftware
fncs.print_string(PS.smep_init(target,software,pathvars._paral,pathvars.tuple_first(),\
pathvars.tuple_sdbw(),pathvars.tuple_sdfw()),4)
fncs.print_string(PS.smep_ff(TMP, PN.DIR4, PN.DIR5, rstfile, xyzfile), 4)
# read rst
try:
tpath2, tcommon2, drst = ff.read_rst(rstfile)
except:
exception = Exc.RstReadProblem(Exception)
exception._var = rstfile
raise exception
fncs.print_string(PS.smep_rst(rstfile, drst), 4)
# correct MEP direction?
if TSLABEL in drst.keys():
ii_s, ii_V, ii_x, ii_g, ii_F, ii_v0, ii_v1, ii_t = drst[TSLABEL]
ii_ic, ii_sign = pathvars._fwdir
if not intl.ics_correctdir(ii_x, ii_v0, ii_ic, ii_sign, tcommon2[3],
tcommon2[4]):
fncs.print_string(
"'fwdir' variable differs from MEP direction in rst file!", 4)
fncs.print_string("* modifying rst internal dictionary...", 8)
new_drst = {}
for key in drst.keys():
ii_s, ii_V, ii_x, ii_g, ii_F, ii_v0, ii_v1, ii_t = drst[key]
ii_s = -ii_s
if ii_v0 is not None: ii_v0 = [-ii for ii in ii_v0]
if ii_v1 is not None: ii_v1 = [-ii for ii in ii_v1]
if "bw" in key: newkey = key.replace("bw", "fw")
else: newkey = key.replace("fw", "bw")
new_drst[newkey] = (ii_s, ii_V, ii_x, ii_g, ii_F, ii_v0, ii_v1,
ii_t)
drst = new_drst
del new_drst
fncs.print_string("* rewriting rst file...", 8)
ff.write_rst(rstfile, tpath2, tcommon2, drst)
# Extension of MEP in rst is bigger
if drst != {}:
lbw, lfw, sbw, sfw, V0bw, V0fw = sd.rstlimits(drst)
pathvars._sbw = min(pathvars._sbw, sbw)
pathvars._sfw = max(pathvars._sfw, sfw)
# Read gts
ts = Molecule()
ts.set_from_gts(gtsTS)
# scaling of frequencies
ts.setvar(fscal=pathvars._freqscal)
# apply iso mod
if pathvars._masses is not None: ts.mod_masses(pathvars._masses)
# setup
ts.setup(mu=pathvars._mu)
ts.ana_freqs(case="cc")
fncs.print_string(PS.smep_ts(ts), 4)
tcommon = (ts._ch, ts._mtp, ts._atnums, ts._masses, ts._mu)
compare_tpath(pathvars.tuple_rst(), tpath2, rstfile)
compare_tcommon(tcommon, tcommon2, rstfile)
# data for single-point calculation
frozen = RW.read_frozen(gtsTS + ".frozen")
oniom_layers = (list(pathvars._oniomh), list(pathvars._oniomm),
list(pathvars._onioml))
spc_args = (tes, TMP, False, frozen, oniom_layers)
spc_fnc = get_spc_fnc(software)
#------------#
# First step #
#------------#
print("")
fncs.print_string("Performing first step of MEP...", 4)
print("")
inputvars = (ts._xcc,ts._gcc,ts._Fcc,ts._symbols,ts._masses,pathvars.tuple_first(),\
spc_fnc,spc_args,drst,pathvars._paral)
(xms, gms, Fms), (v0, v1), (xms_bw, xms_fw) = sd.mep_first(*inputvars)
s1bw = -float(pathvars._ds)
s1fw = +float(pathvars._ds)
# oniom layers?
oniom_ok = pathvars.isONIOMok(ts._natoms, software)
layers = pathvars.get_layers()
fncs.print_string(PS.smep_oniom(layers, ts._natoms, software), 8)
if not oniom_ok: raise Exc.WrongONIOMlayers(Exception)
# Print MEP info
fncs.print_string(PS.smep_first(ts._symbols, ts._xms, v0, v1, layers), 8)
# write rst file
if TSLABEL not in drst.keys():
drst[TSLABEL] = (0.0, ts._V0, xms, gms, Fms, v0, v1, None)
ff.write_rst_head(rstfile, pathvars.tuple_rst(), tcommon)
ff.write_rst_add(rstfile, TSLABEL, drst[TSLABEL])
#------------#
# The MEP #
#------------#
print("")
fncs.print_string("Calculating MEP...", 4)
print("")
fncs.print_string(
"* REMEMBER: data of each step will be saved at %s" % rstfile, 7)
fncs.print_string(" a summary will be printed when finished", 7)
# preparation
xcc_bw = fncs.ms2cc_x(xms_bw, ts._masses, pathvars._mu)
xcc_fw = fncs.ms2cc_x(xms_fw, ts._masses, pathvars._mu)
args_bw = ((xcc_bw,s1bw,ts._symbols,ts._masses,pathvars.tuple_sdbw(),\
spc_fnc,spc_args,drst,ts._Fms,"bw%i") , rstfile,drst)
args_fw = ((xcc_fw,s1fw,ts._symbols,ts._masses,pathvars.tuple_sdfw(),\
spc_fnc,spc_args,drst,ts._Fms,"fw%i") , rstfile,drst)
# execution
if pathvars._paral:
import multiprocessing
pool = multiprocessing.Pool()
out = [
pool.apply_async(onesidemep, args=args)
for args in [args_bw, args_fw]
]
drstbw, pointsbw, convbw = out[0].get()
drstfw, pointsfw, convfw = out[1].get()
del out
# clean up pool
pool.close()
pool.join()
else:
drstbw, pointsbw, convbw = onesidemep(*args_bw)
drstfw, pointsfw, convfw = onesidemep(*args_fw)
# update drst
fncs.print_string("* FINISHED!", 7)
print("")
drst.update(drstbw)
drst.update(drstfw)
points = [TSLABEL] + pointsbw + pointsfw
# empty variables
del drstbw, pointsbw
del drstfw, pointsfw
# Rewrite rst
fncs.print_string("* (re)writing file: %s (sorted version)" % rstfile, 7)
ff.write_rst(rstfile, pathvars.tuple_rst(), tcommon, drst)
print("")
## restrict drst to points
#if restrict: drst = {point:drst[point] for point in points}
# Get limits of rst
lbw, lfw, sbw, sfw, V0bw, V0fw = sd.rstlimits(drst)
convbw, l1bw, l2bw = convbw
convfw, l1fw, l2fw = convfw
if l1bw + l1fw != "":
fncs.print_string("* MEP convergence criteria (epse and epsg):", 7)
print("")
if l1bw != "": fncs.print_string("%s" % l1bw, 9)
if l2bw != "": fncs.print_string("%s" % l2bw, 9)
if l1fw != "": fncs.print_string("%s" % l1fw, 9)
if l2fw != "": fncs.print_string("%s" % l2fw, 9)
print("")
if convbw:
pathvars.converged_in_bw(sbw)
fncs.print_string("CRITERIA FULFILLED in backward dir.!", 9)
fncs.print_string("path stopped at sbw = %+8.4f bohr" % sbw, 9)
print("")
if convfw:
pathvars.converged_in_fw(sfw)
fncs.print_string("CRITERIA FULFILLED in forward dir.!", 9)
fncs.print_string("path stopped at sfw = %+8.4f bohr" % sfw, 9)
print("")
# write molden file
fncs.print_string("* writing file: %s" % xyzfile, 7)
ff.rst2xyz(rstfile, xyzfile, onlyhess=True)
print("")
# reference energy
if pathvars._eref is None: pathvars._eref = V0bw
# return data
return tcommon, drst, pathvars
def calc_mep(itarget, gtsTS, pathvars, tsoftware, TMP):
# data in name
ctc, itc = PN.name2data(itarget)
# Low-Level
if pathvars._dlevel is None:
tcommon, drst, pathvars = obtain_mep(itarget, gtsTS, pathvars,
tsoftware, TMP)
fncs.print_string(PS.smep_table(drst, pathvars._eref), 4)
# Dual-Level
else:
rstfile = PN.get_rst(ctc, itc)
xyzfile = PN.get_rstxyz(ctc, itc)
software, tes = tsoftware
fncs.print_string(PS.smep_init(itarget,software,pathvars._paral,pathvars.tuple_first(),\
pathvars.tuple_sdbw(),pathvars.tuple_sdfw()),4)
fncs.print_string(PS.smep_ff(TMP, PN.DIR4, PN.DIR5, rstfile, xyzfile),
4)
# read rst
tpath, tcommon, drst = ff.read_rst(rstfile)
fncs.print_string(PS.smep_rst(rstfile, drst), 4)
fncs.print_string("Applying Dual-Level...", 4)
print("")
dlevel_xy = [(find_label_in_rst(x, drst)[0], y)
for x, y in pathvars._dlevel.items()]
dlevel_xy = [(x, y) for x, y in dlevel_xy if x is not None]
# Print points (sorted by s value)
dummy = [(drst[xx][0], idx) for idx, (xx, yy) in enumerate(dlevel_xy)]
dummy.sort()
for s_i, idx_i in dummy:
xx_i, yy_i = dlevel_xy[idx_i]
fncs.print_string(
"%+8.4f bohr (%-6s) --> %.7f hartree" % (s_i, xx_i, yy_i), 13)
print("")
# interpolation
drst, points, xx, yyll, yyhl = ispe.ispe(tcommon,
drst,
dlevel_xy,
tension=0.0)
tdleveldata = (points, xx, yyll, yyhl)
# table new values
fncs.print_string(
PS.smep_tableDLEVEL(drst, tdleveldata, pathvars._eref), 4)
return tcommon, drst, pathvars
#--------------------------------#
# Calculations for each reaction #
#--------------------------------#
print(" " * NINIT + "Analytic expressions:")
print("")
print(" " * NINIT + "(1) k = A exp(-B/T) ")
print(" " * NINIT + "(2) k = A*T^n*exp(-B/T) ")
print(" " * NINIT + "(3) k = A*(T/Tr)^n*exp(-B/T) ")
print(" " * NINIT + "(4) k = A*(T/Tr)^n*exp(-B*(T+T0)/(T^2+T0^2))")
print(" " * NINIT + "(5) k = A*((T+T0)/Tr)^n*exp(-B*(T+T0)/(T^2+T0^2))")
print("")
LINES, plotdata = {}, {}
ml = max(len(rcname) for rcname in targets) + 3
for rcname in targets:
print_string(PS.sfit_reaction(rcname), 3)
Rs, TS, Ps = dchem[rcname]
nR, nP = len(Rs), len(Ps)
# perform fitting
fitting_i = fit_reaction(rcname, nR, nP, dall, ltemp)
# generate plotdata
plotdata_i = prepare_plotdata(rcname, nR, nP, ltemp, fitting_i)
# generate summary lines
LINES_i = get_summary_lines(rcname, fitting_i, ltemp, ml)
# update dictionaries
plotdata.update(plotdata_i)
LINES.update(LINES_i)
print_string(PS.sfit_fitting(rcname, fitting_i, ltemp), 5)
# update file with plots
if plotfile is not None and plotdata != {}:
def obtain_sct(dMols, points, VadiSpl, temps, dv1, pathvars, dcfs={}):
print("")
fncs.print_string("Calculating SCT transmission coefficient...", 4)
print("")
# data from pathvars
useics = pathvars._useics
v1mode = pathvars._v1mode
# E0 value
if pathvars._e0 is None:
V1bw = pathvars._eref + VadiSpl.get_alpha()[1]
V1fw = pathvars._eref + VadiSpl.get_omega()[1]
if pathvars._V1R is not None: E0bw = pathvars._V1R
else: E0bw = V1bw
if pathvars._V1P is not None: E0fw = pathvars._V1P
else: E0fw = V1fw
E0 = max(E0bw, E0fw) - pathvars._eref
else:
E0 = pathvars._e0 - pathvars._eref
# some checks
if len(temps) == 0: raise Exc.NoTemps(Exception)
if useics in ["yes", True]: case = "ic"
else: case = "cc"
# MEP LIMITS
sbw, sfw = VadiSpl.get_alpha()[0], VadiSpl.get_omega()[0]
# Part I - Get E0 and VAG
E0 = sct.get_sct_part1(points, VadiSpl, E0)
sAG, VAG = VadiSpl.get_max()
fncs.print_string(PS.ssct_init(E0, VadiSpl, pathvars, v1mode), 8)
# Part II - Calculate tbar, bmfs and mueff
tuple_part2 = (dMols, points, dv1, case, pathvars._muintrpl)
svals, lkappa, ltbar, ldtbar, mu, lmueff, toignore = sct.get_sct_part2(
*tuple_part2)
fncs.print_string(
PS.ssct_mueff(svals, VadiSpl, lkappa, ltbar, lmueff, mu, toignore), 8)
#----------#
# E0 < VAG #
#----------#
if E0 < VAG:
# Part III - Quantum reaction coordinate
fncs.print_string(PS.ssct_E0VAG(E0, VAG), 8)
if pathvars._qrc is not None:
afreq = pathvars._qrcafreq
lEquant = [E0 + E_i for E_i in pathvars._qrclE]
fncs.print_string(PS.ssct_qrc(pathvars), 8)
if pathvars._qrccase != 0: return dcfs, None, E0, VAG
qrc_ZCT = sct.get_sct_part3(svals, mu, VadiSpl, afreq, lEquant, E0,
VAG, temps)
qrc_SCT = sct.get_sct_part3(svals, lmueff, VadiSpl, afreq, lEquant,
E0, VAG, temps)
fncs.print_string(
PS.ssct_probs(qrc_SCT[1], qrc_ZCT[2], qrc_SCT[2], qrc_SCT[3],
sbw, sfw), 12)
kappaI1_zct = qrc_ZCT[0]
kappaI1_sct = qrc_SCT[0]
qrc_Elim = lEquant[1]
else:
kappaI1_zct = None
kappaI1_sct = None
qrc_Elim = None
# apply QRC always?
if not pathvars._qrcauto: qrc_Elim = None
# Part IV - calculate thetas and probs
fncs.print_string(
"Transmission probabilities for Kappa^SAG calculation:", 8)
print("")
outZCT = sct.get_sct_part4(svals, mu, VadiSpl, E0)
outSCT = sct.get_sct_part4(svals, lmueff, VadiSpl, E0)
weights_ZCT, lE_ZCT, probs_ZCT, rpoints_ZCT, diffs_ZCT, (
pZCT0, rpZCT0) = outZCT
weights_SCT, lE_SCT, probs_SCT, rpoints_SCT, diffs_SCT, (
pSCT0, rpSCT0) = outSCT
# include also prob at E=E0 (pZCT0 and pSCT0)
fncs.print_string(PS.ssct_probs( [E0]+lE_SCT ,\
[pZCT0 ]+probs_ZCT,\
[pSCT0 ]+probs_SCT,\
[rpSCT0]+rpoints_SCT,sbw,sfw),8)
fncs.print_string(PS.ssct_diffs(lE_SCT, diffs_SCT), 8)
# Part V - calculate coefficients
ZCTdata = sct.get_sct_part5(lE_ZCT, probs_ZCT, weights_ZCT, E0, VAG,
temps, kappaI1_zct, qrc_Elim)
SCTdata = sct.get_sct_part5(lE_SCT, probs_SCT, weights_SCT, E0, VAG,
temps, kappaI1_sct, qrc_Elim)
ZCT, lIi_ZCT, RTE_ZCT, INTG_ZCT, bqrcZCT = ZCTdata
SCT, lIi_SCT, RTE_SCT, INTG_SCT, bqrcSCT = SCTdata
fncs.print_string(
PS.ssct_kappa(temps,
ZCT,
lIi_ZCT,
RTE_ZCT,
E0,
bqrcZCT,
case="zct"), 8)
fncs.print_string(
PS.ssct_kappa(temps,
SCT,
lIi_SCT,
RTE_SCT,
E0,
bqrcSCT,
case="sct"), 8)
#----------#
# E0 > VAG #
#----------#
else:
ZCT = [1.0 for T in temps]
SCT = [1.0 for T in temps]
INTG_ZCT = None
INTG_SCT = None
RTE_ZCT = None
RTE_SCT = None
fncs.print_string(PS.ssct_E0_above_VAG(E0, VAG), 8)
fncs.print_string(PS.ssct_onlykappa(temps, ZCT, SCT), 8)
# data for the plot
forplot = (svals, lmueff, temps, INTG_ZCT, INTG_SCT, RTE_ZCT, RTE_SCT, E0,
VAG)
# save data
dcfs["zct"] = ZCT
dcfs["sct"] = SCT
return dcfs, forplot, E0, VAG
rcons.main(idata, status, case, dargs["rcons"])
elif option == "kmc":
kmc.main(idata, status, case, dargs["kmc"])
elif option == "kies":
kies.main(idata, status, case)
elif option == "fit":
fit.main(idata, status, case, dargs["fit"])
elif option == "plot":
plot.main(case, dargs["plot"])
print("")
print(" ===========================================================")
break
# User asked for nothing. Print help!
if not IN_OPTS:
print_string(HELP_main, 2)
return
# Print elapsed time
t2 = time.time()
timeline = "| Total Elapsed Time: %5.1f %5s |" % time2human(
t2 - t1, "secs")
print(" " * 25 + "-" * len(timeline))
print(" " * 25 + timeline)
print(" " * 25 + "-" * len(timeline))
print("")
#==========================================================#
#==========================================================#
def get_path_sctconv(itarget, gtsTS, pathvars, tsoftware, ltemp, TMP, symmetry,
plotfile):
# assert no DLEVEL will be done (just in case)
pathvars._dlevel = None
# The step to be increased
hessds = abs(pathvars._hsteps * pathvars._ds)
# some initializations
convlist_sct = []
convlist_lim = []
# do we have products?
bool_prods = pathvars._V1P is not None
ntimesdecrease = 0
# (a) Define the limits of MEP to calculate SCT
sbw0, sfw0 = 0.0, 0.0
while sbw0 > -0.5:
sbw0 -= hessds
while sfw0 < +0.5:
sfw0 += hessds
sbwN, sfwN = pathvars._sbw, pathvars._sfw
if fncs.is_greatereq(sbwN, sbw0, EPS_MEPS): sbw0 = sbwN + hessds
if fncs.is_smallereq(sfwN, sfw0, EPS_MEPS): sfw0 = sfwN - hessds
# (b) Update pathvars and calculate MEP
pathvars._sbw = sbw0
pathvars._sfw = sfw0
fncs.print_string("--> scterr keyword was detected! <--", 4)
fncs.print_string(
" MEP limited to: [%.4f,%.4f] (bohr)\n" % (sbw0, sfw0), 4)
tcommon, drst, pathvars = calc_mep(itarget, gtsTS, pathvars, tsoftware,
TMP)
# (c) if MEP was calculated previously, it may be longer
lbw, lfw, sbw, sfw, V0bw, V0fw = sd.rstlimits(drst)
if fncs.is_smaller(sbw, sbw0, EPS_MEPS): sbw0 = sbw + 2 * hessds
if fncs.is_greater(sfw, sfw0, EPS_MEPS): sfw0 = sfw - 2 * hessds
# (c) Go ahead
pathvars._sbw, pathvars._sfw = sbw0, sfw0
while True:
# Reduce MEP to current limits
sbwi = pathvars._sbw
sfwi = pathvars._sfw
fncs.print_string(
"--> CALCULATING COEFFICIENTS IN [%.4f,%.4f] (in bohr)<--" %
(sbwi, sfwi), 4)
drst = {
label: data
for label, data in drst.items()
if in_interval(data[0], sbwi, sfwi)
}
# Calculate corresponding coefficients
dcfs, pathvars, palpha, pomega = calc_coefs(itarget, tcommon, drst,
pathvars, ltemp, symmetry,
plotfile)
# expand data
try:
SCT = dcfs["sct"]
except:
return dcfs
# Save data only for lower temperature
convlist_sct.append(SCT[0])
convlist_lim.append((sbwi, sfwi))
# Check convergence
if len(convlist_sct) > 1:
SCT_a = convlist_sct[-1]
SCT_b = convlist_sct[-2]
dif100 = 100 * abs(SCT_a - SCT_b) / SCT_a
# reduce value only to two decimal places
dif100 = float("%9.2f" % dif100)
# compare
converged = (dif100 <= pathvars._scterr)
if float("%.4E" % SCT_a) <= float("%.4E" % SCT_b):
ntimesdecrease += 1
else:
converged = False
# Be more strict with convergence if no products
if not bool_prods and ntimesdecrease < 2: converged = False
# Print convergence table
tuple_table = (convlist_sct, convlist_lim, pathvars._scterr, converged)
fncs.print_string(PS.ssct_convergence(*tuple_table), 4)
if converged: break
# If current limits are outside required, break
if fncs.is_smallereq(sbwi, sbwN, EPS_MEPS) or fncs.is_greatereq(
sfwi, sfwN, EPS_MEPS):
fncs.print_string(
"WARNING: SCT transmission coefficient is NOT converged YET!",
4)
fncs.print_string(
" Unfortunately, the MEP limit defined by the user", 4)
fncs.print_string(" was reached...", 4)
fncs.print_string(
" [sbw,sfw] = [%.4f,%.4f]" % (sbwN, sfwN), 4)
print("")
break
# Increase MEP
sbwi = pathvars._sbw
sfwi = pathvars._sfw
V1bw = palpha[1] + pathvars._eref
V1fw = pomega[1] + pathvars._eref
lbw, lfw, sbw, sfw, V0bw, V0fw = sd.rstlimits(drst)
pathvars.increase_svals(V0bw, V0fw, V1bw, V1fw)
sbwj = pathvars._sbw
sfwj = pathvars._sfw
fncs.print_string(
"--> MEP will be calculated between [%.4f,%.4f] (in bohr) <--" %
(sbwj, sfwj), 4)
print("")
fncs.print_string("sbw: %+8.4f --> %+8.4f bohr" % (sbwi, sbwj), 8)
fncs.print_string("sfw: %+8.4f --> %+8.4f bohr" % (sfwi, sfwj), 8)
print("")
tcommon, drst, pathvars = calc_mep(itarget, gtsTS, pathvars, tsoftware,
TMP)
pathvars._sbw = sbwj
pathvars._sfw = sfwj
del drst
return dcfs, converged
units = "s^{-1} cc^{%i} molecule^{-%i}" % (num - 1,
num - 1)
else:
units = "s^{-1}"
# Fitting process
print " Fitting parameters:"
print
for rctype in "tst,cvt,tstzct,cvtzct,tstsct,cvtsct".split(","):
if case == 0: key = "%s.%s.%s" % (rctype, rcname, direc)
else: key = "anh%s.%s.%s" % (rctype, rcname, direc)
if key not in dall["rcons"].keys(): continue
rcons = dall["rcons"][key]
# the fitting
khu, dfit = fit2analytic(ltemp, rcons, num)
string, lines = PS.sfit_anafit(dfit, key)
print_string(string, 9)
# save lines for KMC
LINES.update({(anatype, rctype, case, rcname, direc): line
for anatype, line in lines.items()})
# save data for plotting
if case == 0: d4plot[rctype] = (khu, dfit)
else: d4plot["anh" + rctype] = (khu, dfit)
plotdata.update(
manage_data_for_plot_rcons(rcname, direc, ltemp,
d4plot, units))
if plotfile is not None and plotdata != {}:
write_plotfile(plotfile, plotdata)
# create loop list
loop = [(rctype,case) \
for case in [0,1] \
def deal_with_path(target, dlevel, software, ltemp, dctc, pathvars, dtes,
dchem, dhighlvl, dimasses):
dof = PN.get_dof(dlevel)
plotfile = PN.get_plf(dlevel)
# gts file for this TS
ctc, itc = PN.name2data(target)
gtsTS = dctc[ctc].gtsfile(itc)
# rotational symmetry
moleculeTS = Molecule()
moleculeTS.set_from_gts(gtsTS)
symmetry = str(moleculeTS._pgroup), int(moleculeTS._rotsigma)
# temporal folder
TMP = PN.TMPi % (target)
# if exists,remove content (unless keeptmp is activated)
# (to avoid reading old files from different levels of calculation)
if os.path.exists(TMP) and not pathvars._keeptmp:
shutil.rmtree(TMP, ignore_errors=True)
# split target
ctc, itc = PN.name2data(target)
# name of rst file
rstfile = PN.get_rst(ctc, itc)
# tuple software
tes = dtes.get(software, {}).get(ctc, None)
tsoftw = (software, tes)
# internal coordinates
if itc in dctc[ctc]._dics.keys(): ics = dctc[ctc]._dics[itc]
elif "*" in dctc[ctc]._dics.keys(): ics = dctc[ctc]._dics["*"]
else: ics = None
if itc in dctc[ctc]._dicsbw.keys(): icsbw = dctc[ctc]._dicsbw[itc]
elif "*" in dctc[ctc]._dicsbw.keys(): icsbw = dctc[ctc]._dicsbw["*"]
else: icsbw = None
if itc in dctc[ctc]._dicsfw.keys(): icsfw = dctc[ctc]._dicsfw[itc]
elif "*" in dctc[ctc]._dicsfw.keys(): icsfw = dctc[ctc]._dicsfw["*"]
else: icsfw = None
# path variables
pathvars.set_ics(ics, icsbw, icsfw) # before setup3!!
pathvars.apply_specific(itc)
pathvars.setup1()
pathvars.setup2()
pathvars.setup3()
# Set Eref (from reaction)
pathvars.set_eref_from_reaction(target, dchem, dof)
# Quantum reaction coordinate qrc
pathvars.prepare_qrc(dchem, dctc, dimasses)
# frequency scaling factor
pathvars._freqscal = float(dctc[ctc]._fscal)
# if dlevel --> no convergence and dlevel data
if dlevel:
exception = Exc.NoDLEVELdata(Exception)
pathvars._scterr = None
keydhl = "%s.%s.path" % (ctc, itc)
if keydhl not in dhighlvl.keys():
# maybe only TS
keydhl = "%s.%s" % (dctc[ctc]._root, itc)
if keydhl in dhighlvl.keys():
dictE = {0.0: dhighlvl[keydhl]}
else:
global WARNINGS
WARNINGS.append("No high-level data for %s" % target)
raise exception
else:
dictE = dhighlvl[keydhl]
pathvars._dlevel = dictE
# LOGGER
pof = PN.get_pof(dlevel, "path", target)
sys.stdout = Logger(pof, "w", True)
sys.stdout.writeinfile(PS.init_txt())
#string
fncs.print_string(PS.smep_title(target, pathvars, pof), 2)
# Was previously converged???
ffloat = "%.3f"
drstconv = RW.read_rstconv()
if target in drstconv.keys() and not dlevel and os.path.exists(rstfile):
lowtemp, useics, scterr, converged = drstconv[target]
b0 = (converged == "yes")
b1 = (pathvars._useics == useics)
b2 = (ffloat % pathvars._scterr == ffloat % scterr)
b3 = (ffloat % min(ltemp) == ffloat % lowtemp)
if b0 and b1 and b2 and b3:
pathvars._scterr = None
fncs.print_string("THIS PATH IS STORED AS CONVERGED!\n", 4)
tpath, tcommon, drst = ff.read_rst(rstfile)
lbw, lfw, sbw, sfw, V0bw, V0fw = sd.rstlimits(drst)
pathvars._sbw = sbw
pathvars._sfw = sfw
del drst
#----------------#
# calculate path #
#----------------#
# 1. Only MEP
if not pathvars._beyondmep:
common, drst, pathvars = calc_mep(target, gtsTS, pathvars, tsoftw, TMP)
dcoefs = {}
del drst
# raise error
raise Exc.OnlyMEP(Exception)
# 2. MEP expanded till SCT convergence
elif pathvars.sct_convergence():
dcoefs, converged = get_path_sctconv(target, gtsTS, pathvars, tsoftw,
ltemp, TMP, symmetry, plotfile)
# save convergence in file!
drstconv = RW.read_rstconv()
if converged:
drstconv[target] = (min(ltemp), pathvars._useics, pathvars._scterr,
"yes")
else:
drstconv[target] = (min(ltemp), pathvars._useics, pathvars._scterr,
"no")
RW.write_rstconv(drstconv)
# 3. Coefs with the current MEP extension
else:
tcommon, drst, pathvars = calc_mep(target, gtsTS, pathvars, tsoftw,
TMP)
dcoefs, pathvars, palpha, pomega = calc_coefs(target, tcommon, drst,
pathvars, ltemp,
symmetry, plotfile)
del drst
# print summary with the coefficients
fncs.print_string(PS.spath_allcoefs(ltemp, dcoefs), 3)
# return data
return dcoefs, pathvars
