def data_target(target, dall, ltemp):
# convert to list
target = target2list(target)
# initialize
tot_V0 = 0.0
tot_V1 = 0.0
tot_Q = [1.0 for T in ltemp]
tot_ANH = [1.0 for T in ltemp]
trg_ANH = []
# everything ok?
if target is None: return None, None, None, tot_ANH, trg_ANH
# read data
for trg in target:
ctc, itc = PN.name2data(trg)
# Get key
if itc is None: key = PN.struckey(ctc, "msho")
else: key = PN.struckey(ctc, itc)
# look for data
try:
V0, V1, pfns = dall["pfn"][key]
except:
raise Exc.NoData
# add energies to total
tot_V0 += V0
tot_V1 += V1
# update total partition function
tot_Q = [q_i * q_j for q_i, q_j in zip(tot_Q, pfns)]
# anharmonicity
if ctc in dall["anh"].keys():
anh = dall["anh"][ctc]
tot_ANH = [r1 * r2 for r1, r2 in zip(tot_ANH, anh)]
trg_ANH.append(trg)
# return data
return tot_V0, tot_V1, tot_Q, tot_ANH, trg_ANH
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():
print " * '%s' not in '%s'" % (target, PN.IFILE1)
print
continue
if ctc not in dpath.keys():
print " * '%s' not in '%s'" % (target, PN.IFILE3)
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 get_targets(targets, dctc):
# No targets selected
if targets == [] or targets == "*":
targets = [
PN.struckey(ctc, itc) for ctc in dctc.keys()
for itc, weight in dctc[ctc]._itcs
]
targets.sort()
return targets
# Check targets
itargets = []
for target in targets:
np = target.count(".")
# a whole ctc is selected
if np == 0:
ctc = target
if ctc not in dctc.keys(): continue
itargets += [
PN.struckey(ctc, itc) for itc, weight in dctc[ctc]._itcs
]
# a specific itc
elif np == 1:
ctc, itc = target.split(".")
if ctc not in dctc.keys(): continue
itcs = [itc_i for itc_i, weight_i in dctc[ctc]._itcs]
if itc not in itcs: continue
itargets += [target]
return itargets
def conformer_contributions(ltemp, dpfn, ctc, itcs):
# get contributions
dchi = {}
for itc, weight in itcs:
V0i, V1i, Qi = dpfn[PN.struckey(ctc, itc)]
V0, V1, Q = dpfn[PN.struckey(ctc, "msho")]
# calculate contribution
expvec = [np.exp(-(V1i - V1) / KB / T) for T in ltemp]
chi = weight * np.array(Qi) / np.array(Q) * np.array(expvec)
# save data
dchi[itc] = chi
return dchi
def highlevel_mep(ctc, itc, keyHL_sp, software, dtesHL, dhighlvl, points):
# key for dhighlvl
keyHL_path = "%s.%s.path" % (ctc, itc)
# initialize dictE
dictE = {}
# folder for calculation and file name
TMP = PN.TMPHLi % PN.struckey(ctc, itc)
# template and function for calculation
tes = dtesHL.get(software, {}).get(ctc, None)
spc_fnc = get_spc_fnc(software)
# extra-arguments for spc_fnc
clean = False # do not delete files
bhess = False # do not calculate hessian (no needed actually)
eargs = (tes, TMP, clean)
# rst file
rstfile = PN.get_rst(ctc, itc)
tpath2, tcommon2, drst = ff.read_rst(rstfile)
if drst == {}:
yield None, keyHL_path, (None, None), None, "emptyrst"
return
ch, mtp, atonums, masses, mu = tcommon2
symbols = fncs.atonums2symbols(atonums)
# define points
allpoints = sorted_points(drst, hess=False)
for point in points:
if point.startswith("auto"):
auto, nbw, nfw = point.split("_")
points = auto_points(drst, allpoints, int(nbw), int(nfw))
break
# loop in points
for point_i in points:
# name for files
mname = "%s.%s.%s" % (ctc, itc, point_i)
# get label
label_i, s_i = find_label_in_rst(point_i, drst)
# tuple for identify
tuple_ID = (s_i, label_i)
# not in drst?
if label_i is None:
yield point_i, keyHL_path, tuple_ID, None, "noinrst"
# already calculated
elif label_i in dhighlvl.get(keyHL_path, {}).keys():
yield point_i, keyHL_path, tuple_ID, dhighlvl[keyHL_path][
label_i], "already"
# HL-calculation
else:
if s_i == 0.0:
Ehl_sp = dhighlvl.get(keyHL_sp, None)
if Ehl_sp is not None:
yield point_i, keyHL_path, tuple_ID, Ehl_sp, "saddlefromsp"
continue
# get xcc from rst
xms = drst[label_i][2]
xcc = fncs.ms2cc_x(xms, masses, mu)
# calculation
try:
out_spc = spc_fnc(xcc, symbols, bhess, mname, eargs)
yield point_i, keyHL_path, tuple_ID, out_spc[4], "calculated"
except:
yield point_i, keyHL_path, tuple_ID, None, "fail"
def get_V0HL_list(ctc, itcs, dhighlvl):
list_V0HL = []
for itc, weight in itcs:
key = PN.struckey(ctc, itc)
V0HL = dhighlvl.get(key, None)
list_V0HL.append(V0HL)
return list_V0HL
def get_TSratios(ctc, itcs, V1TS, QTS, ltemp, dall):
'''
ratio = QTS(i)/QTS * exp(-dE(i) * beta)
'''
exception = Exc.LostConformer(Exception)
tst_ratios = {}
for itc, weight in itcs:
key = PN.struckey(ctc, itc)
if key not in dall["pfn"].keys():
exception._var = key
raise exception
V0_i, V1_i, Q_i = dall["pfn"][key]
ratio = [0.0 for T in ltemp]
dE = (V1_i - V1TS)
for idx, T in enumerate(ltemp):
ratio[idx] = weight * Q_i[idx] / QTS[idx] * np.exp(-dE / KB / T)
tst_ratios[itc] = ratio
# get individual data
return tst_ratios
def get_corrfactors(ltemp, ctc, itcs, dall, tst_ratios):
'''
k^(x) = 1/(hbeta) * QTS/QR * exp(dE*beta) * GAMMA^(x)
GAMMA^(x) = sum_i weight_i * QTS_i/QTS * exp(dE_i*beta) * Gamma_i =
= sum_i ratioTST_i * Gamma_i
'''
cf = {}
cf["cvt"] = {}
cf["cvtzct"] = {}
cf["cvtsct"] = {}
cf["tstzct"] = {}
cf["tstsct"] = {}
for itc, weight in itcs:
tsname = PN.struckey(ctc, itc)
# individual coefs
cvt = dall.get("cvt", {}).get(tsname, None)
zct = dall.get("zct", {}).get(tsname, None)
sct = dall.get("sct", {}).get(tsname, None)
cagtst = dall.get("cagtst", {}).get(tsname, None)
cagcvt = dall.get("cagcvt", {}).get(tsname, None)
# correction
try:
cf_cvt = np.array(prod_list((cvt, )))
except:
cf_cvt = None
try:
cf_cvtzct = np.array(prod_list((zct, cvt, cagcvt)))
except:
cf_cvtzct = None
try:
cf_cvtsct = np.array(prod_list((sct, cvt, cagcvt)))
except:
cf_cvtsct = None
try:
cf_tstzct = np.array(prod_list((zct, cagtst)))
except:
cf_tstzct = None
try:
cf_tstsct = np.array(prod_list((sct, cagtst)))
except:
cf_tstsct = None
# save
cf["cvt"][itc] = cf_cvt
cf["cvtzct"][itc] = cf_cvtzct
cf["cvtsct"][itc] = cf_cvtsct
cf["tstzct"][itc] = cf_tstzct
cf["tstsct"][itc] = cf_tstsct
# get total
for rc in cf.keys():
tot_cf = np.array([0.0 for T in ltemp])
fail = False
for itc, weight in itcs:
tst_ratio = tst_ratios[itc]
cf_i = cf[rc][itc]
if cf_i is None:
fail = True
continue
tot_cf += tst_ratio * cf_i
if fail: cf[rc]["total"] = None
else: cf[rc]["total"] = tot_cf
return cf
if fstatus == -1: exit()
# expand case
(dof, hlf, plotfile), dlevel, software = case
#-------------------------------------------------------#
print " Selected software: %s" % software
print
targets = get_targets(targets, dctc)
# Print targets
if len(targets) != 0:
print " High-level (HL) calculations will be carried out for:"
ml = max([len(target) for target in targets] + [1])
for target in targets:
ctc, itc = PN.name2data(target)
TMP = PN.TMPHLi % PN.struckey(ctc, itc)
print " %s (TMP folder: %s)" % ("%%-%is" % ml % target, TMP)
print
else:
print " No valid target(s) for High-level (HL) calculations"
print
return
# read high-level output file
dhighlvl = RW.read_highlevelfile(hlf)
# loop over each target
print " Carrying out HL-calculations:"
print
ml = max([len(target) for target in targets])
cols = ("target", "point identifier", "s value (bohr)", "E_HL (hartree)")
def get_reaction_energies(TS, dchem, dof):
'''
* checks the reactions which involved the target transition
state (TS) in order to extract V0 and V1 for reactants
and products
'''
# initialize variables
reaction = None
Eref = None
V0R = None
V0P = None
V1R = None
V1P = None
GibbsR = None
# select reaction
ctc, itc = PN.name2data(TS)
for rname in dchem.keys():
Rs, ts, Ps = dchem[rname]
ctc2, itc2 = PN.name2data(ts)
if ctc == ctc2:
reaction = rname
if itc == itc2: break
# no reaction?
if reaction is None: return reaction, V0R, V0P, V1R, V1P, GibbsR
# read dof
dall = RW.read_alldata(dof)[0]
# get energy from reaction
Rs = dchem[reaction][0]
Ps = dchem[reaction][2]
# reactants
if len(Rs) != 0:
V0R, V1R = 0.0, 0.0
for R in Rs:
ctc, itc = PN.name2data(R)
if itc is None: key = PN.struckey(ctc, "msho")
else: key = R
data = dall["pfn"].get(key, None)
if data is None:
V0R, V1R = None, None
break
V0, V1, pfns = data
V0R += V0
V1R += V1
# Gibbs energy
if key in dall["gibbs"].keys():
gibbs = dall["gibbs"][key]
if GibbsR is None: GibbsR = gibbs
else: GibbsR = [gi + gj for gi, gj in zip(GibbsR, gibbs)]
# products
if len(Ps) != 0:
V0P, V1P = 0.0, 0.0
for P in Ps:
ctc, itc = PN.name2data(P)
if itc is None: key = PN.struckey(ctc, "msho")
else: key = P
data = dall["pfn"].get(key, None)
if data is None:
V0P, V1P = None, None
break
V0, V1, pfns = data
V0P += V0
V1P += V1
# Output
return reaction, V0R, V0P, V1R, V1P, GibbsR
def calculate_QMSHO_for_ctc(Cluster, ltemp, dimasses={}, tupleHL=None):
# expand data
ctc = Cluster._ctc
itcs = Cluster._itcs
eslist = Cluster._es
sptype = Cluster._type
fscal = Cluster._fscal
diso = Cluster._diso
if tupleHL is None: dlevel, dhighlvl = False, {}
else: dlevel, dhighlvl = tupleHL
# get list of gts files and check existency
gtsfiles = Cluster.gtsfiles()
exception = Exc.LackOfGts(Exception)
for gts in gtsfiles:
if not os.path.exists(gts):
exception._var = gts
raise exception
# DLEVEL
if dlevel: V0HLs = get_V0HL_list(Cluster._root, itcs, dhighlvl)
else: V0HLs = [None for itc, weight in itcs]
# Generate Molecule instances
molecules = []
mass = None
V0LLs = []
for idx, gts in enumerate(gtsfiles):
itc, weight = itcs[idx]
# tuple with isotopic
if itc in diso.keys(): iso = diso[itc]
elif "*" in diso.keys(): iso = diso["*"]
else: iso = None
tiso = (iso, dimasses)
# prepare and add molecule
molecule = molecule_prep(gts, eslist, tiso, fscal)
# save low-level
V0LLs.append(float(molecule._V0))
# apply dlevel
if V0HLs[idx] is not None:
molecule._V0 = V0HLs[idx]
molecule._ccV1 = molecule._V0 + molecule._cczpe
# save molecule
molecules.append(molecule)
# Get min of V0 and V1
V0 = min([molecule._V0 for molecule in molecules])
V1 = min([molecule._ccV1 for molecule in molecules])
# String
string = ""
if dlevel:
string += " keyword --dlevel activated: applying High-Level energies to this STRUC\n"
string += "\n"
string += " * Low-level (LL) and high-level (HL) energies (in hartree):\n"
string += "\n"
string += " ---------------------------------------------------\n"
string += " conformer | LL energy | HL energy \n"
string += " ---------------------------------------------------\n"
for idx, (itc, weight) in enumerate(itcs):
if V0HLs[idx] is None: V0HL = " - "
else: V0HL = "%+17.8f" % V0HLs[idx]
string += " %-9s | %+17.8f | %s \n" % (itc, V0LLs[idx],
V0HL)
string += " ---------------------------------------------------\n"
string += "\n"
if None in V0HLs:
string += " * FAIL!! Not enough data... DUAL-LEVEL will be omitted!\n"
string += "\n"
global WARNINGS
WARNINGS.append("Dual-level was not applied to %s..." % ctc)
string += add_iblank(PS.getstring_ctc(sptype, molecules, itcs, V0, V1), 4)
# Compare masses
for molecule in molecules:
if mass is None: mass = molecule._mass
# compare masses
if abs(mass - molecule._mass) * AMU > EPS_AMU:
global WARNINGS
WARNINGS.append("Mass inconsistences in %s" % ctc)
exception = Exc.DiffMassConf(Exception)
exception._var = string
raise exception
# get partition functions for each molecule (and for CTC)
dpfn = {}
dgibbs = {}
pfn_tot = [0.0 for T in ltemp]
pfn_gibbs = [0.0 for T in ltemp] # goes without sigma_rot
for idx, molecule in enumerate(molecules):
itc, weight = itcs[idx]
V0_i, V1_i, pf_i, tuple_i = molecule_pfns(molecule, ltemp, sptype)
key = PN.struckey(ctc, itc)
# save individual pfn and gibbs free energy
rotsigma = molecule._rotsigma
gibbs_i = [
V1_i - KB * T * np.log(q_j * rotsigma)
for T, q_j in zip(ltemp, pf_i)
]
dpfn[key] = (V0_i, V1_i, pf_i)
dgibbs[key] = gibbs_i
# update MSHO values
rel_V1 = V1_i - V1
for idx, T in enumerate(ltemp):
beta = 1.0 / (T * KB)
pfn_tot[idx] += weight * pf_i[idx] * np.exp(-rel_V1 * beta)
pfn_gibbs[idx] += weight * pf_i[idx] * np.exp(
-rel_V1 * beta) * rotsigma
# add to string
pf_PIB, pf_RR, pf_HO, pf_ele = tuple_i
string += " Conformation: %s\n" % itc
string += add_iblank(molecule.info_string(), 7)
string += " partition functions (with regards electronic energy + ZPE):\n"
string += add_iblank(
PS.getstring_pfn1(ltemp, pf_i, pf_PIB, pf_RR, pf_HO, pf_ele), 7)
# save Q_MSHO
dpfn[PN.struckey(ctc, "msho")] = (V0, V1, pfn_tot)
# save Gibbs_MSHO
gibbs_tot = [V1 - KB * T * np.log(q_j) for T, q_j in zip(ltemp, pfn_gibbs)]
dgibbs[PN.struckey(ctc, "msho")] = gibbs_tot
# Add to string
nconfs = sum([weight for name, weight in itcs])
if nconfs > 1:
dchi = conformer_contributions(ltemp, dpfn, ctc, itcs)
string += " MSHO partition function (QMSHO) with regard to min(V1):\n"
string += "\n"
string += add_iblank(PS.getstring_pfn2(ltemp, pfn_tot), 10)
string += " Individual contributions to QMSHO:\n"
string += "\n"
string += add_iblank(PS.string_contributions(itcs, ltemp, dchi), 10)
else:
dchi = {}
return dpfn, dgibbs, string, dchi
global WARNINGS
WARNINGS.append("Problem with %s" % ctc)
if type(exception) == Exc.DiffMassConf:
print_string(exception._var, NBS)
continue
if type(exception) == Exc.LackOfGts:
error_line = "ERROR: Unable to find '%s'" % exception._var
print " " + error_line
print
continue
raise exception
# print info
print_string(string, NBS)
# anharmonicity??
anhfile = dctc[ctc]._anh
V0, V1, QMSHO = dpfn_i[PN.struckey(ctc, "msho")]
ZPEMSHO = V1 - V0
RATIO, string = deal_with_anh(anhfile, ltemp, ZPEMSHO, QMSHO)
if string != "":
print_string(string, 7)
if RATIO is None:
global WARNINGS
WARNINGS.append("Anharmonicity IGNORED for %s" % ctc)
# add data of weights to plot
if plotfile is not None and dchi != {}:
plotdata = {}
plotdata.update(manage_data_for_plot_weights(ctc, ltemp, dchi))
write_plotfile(plotfile, plotdata)
# update dictionary
dpfn.update(dpfn_i)
dgibbs.update(dgibbs_i)
