def execute(ifile,ofile,err,folder=None):
# Add folder to names
if folder is not None:
if not folder.endswith("/"): folder = folder + "/"
ifile = folder + ifile
ofile = folder + ofile
err = folder + err
# Execution file?
set_EXE()
check_EXE()
# Exception
exception = Exc.CalcFails(Exception)
exception._var = ofile
# Execute Gaussian
command = "%s <%s 1>%s 2>%s"%(EXE,ifile,ofile,err)
# Try up to NN times
NN = 5
for ii in range(NN):
try : status = os.system(command)
except: status = 0
# interrupted by ctrl+c (status = 2?)
if status == 2: raise KeyboardInterrupt
# Get log status
logstatus = log_status(ofile)
# Act according log status
# (a) Normal termination
if logstatus == 1 : break
# (b) empty file, no file or open-new-file error
elif logstatus in (-1,0,2):
time.sleep(1)
continue
# (c) other type of error
else: raise exception
return status
def obtain_cvt(dMols,
points,
VadiSpl,
temps,
pathvars,
si=-float("inf"),
sj=+float("inf"),
dcfs={}):
print("")
fncs.print_string("Calculating CVT variational coefficient...", 4)
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 get_contributions(ctc, dall, dctc, ltemp):
if ctc not in dctc.keys(): return None
# Only one conformer?
if len(dctc[ctc]._itcs) == 1:
itc, weight = dctc[ctc]._itcs[0]
dchi = {itc: [1.0 for T in ltemp]}
return dchi
# Get total partition function
V0, V1, PFN = dall["pfn"]["%s.msho" % ctc]
# Get ratios
dchi = {}
for itc, weight in dctc[ctc]._itcs:
# Get individual partition functions
try:
V0i, V1i, PFNi = dall["pfn"][PN.struckey(ctc, itc)]
# Calculate contribution
dE = (V1i - V1)
exp_arg = [-dE / pc.KB / T for T in ltemp]
ratio_pfn = [weight * pfi / pftot for pfi, pftot in zip(PFNi, PFN)]
chi_i = [
aa * fncs.exp128(bb) for aa, bb in zip(ratio_pfn, exp_arg)
]
dchi[itc] = np.array(chi_i)
except:
exception = Exc.LostConformer(Exception)
exception._var = PN.struckey(ctc, itc)
raise exception
# Return data
return dchi
def random_angle(tdomain=[(0, 360)]):
for ii in range(10**6):
# random angle as integer
angle = int(round(random.random() * 360))
# assert in range
if fncs.float_in_domain(angle, tdomain): return angle
# unable to generate angle
exception = exc.UnableGenRandAng(Exception)
exception._domain = tdomain
raise exception
def read_orcaout(orca_out):
# Read lines
lines = read_file(orca_out)
# CHECK FILE IS ORCA OUT
correct = False
for line in lines:
if "This ORCA versions uses" in line:
correct = True
break
if not correct: raise Exc.FileType(Exception)
# Initialize
ch, mtp, E = None, None, None
xcc, symbols, atonums = [], [], []
# basis set
basisset = ""
try:
for line in lines:
if "utilizes the basis" in line:
basisset = line.split(":")[1]
break
except:
pass
# hamiltonian
hamiltonian = ""
try:
for idx, line in enumerate(lines):
if "Hamiltonian:" in line:
hamiltonian = lines[idx + 1].split()[-1]
break
except:
pass
# level of calculation
calclevel = hamiltonian + " " + basisset
# Get ch, mtp, E
pos = None
for idx in range(len(lines)):
line = lines[idx]
if "Total Charge Charge" in line: ch = int(line.split()[-1])
if "Multiplicity Mult" in line: mtp = int(line.split()[-1])
if "FINAL SINGLE POINT ENERGY " in line: E = float(line.split()[-1])
if "CARTESIAN COORDINATES (A.U.)" in line: pos = idx
# Get xcc, symbols, atonums
if pos is None:
sys.exit(
"Unable to find 'CARTESIAN COORDINATES (A.U.)' label in file!")
pos = pos + 3
for line in lines[pos:]:
line = line.strip()
if line == "": break
idx, symbol, atonum, dummy, mass, x, y, z = line.split()
xcc = xcc + [float(x), float(y), float(z)]
symbols.append(symbol)
atonums.append(int(atonum.split(".")[0]))
# Return
return xcc, atonums, ch, mtp, E, calclevel.strip()
def mep_first(xcc,
gcc,
Fcc,
symbols,
masses,
var_first,
spc_fnc,
spc_args,
drst={},
parallel=False):
#global PARALLEL, delayed, multiprocessing, Parallel
#PARALLEL, delayed, multiprocessing, Parallel = fncs.set_parallel(parallel)
ds, mu, cubic, idir = var_first
# convert cubic variable to d3 (in bohr)
d3 = cubic2float(cubic)
# mass-scaled
xcc = fncs.shift2com(xcc, masses)
xms = fncs.cc2ms_x(xcc, masses, mu)
gms = fncs.cc2ms_g(gcc, masses, mu)
Fms = fncs.cc2ms_F(Fcc, masses, mu)
# Data in backup?
if TSLABEL in drst.keys():
si, E, xms2, gms, Fms, v0, v1, t = drst[TSLABEL]
gms = np.array(gms)
Fms = np.array(Fms)
v0 = np.array(v0)
if v1 is not None: v1 = np.array(v1)
same = fncs.same_geom(xms, xms2)
if not same: raise Exc.RstDiffTS(Exception)
else:
# Calculation of v0
freqs, evals, evecs = fncs.calc_ccfreqs(Fcc, masses, xcc)
ifreq, Lms = get_imagfreq(freqs, evecs)
v0 = fncs.normalize_vec(Lms)
v0 = correctdir_v0(xms, v0, idir, masses, mu)
# Calculation of v1
if d3 is None: v1 = None
else:
v1 = calculate_v1(xms, v0, Fms, symbols, masses, mu, d3, spc_fnc,
spc_args, parallel)
# Final structures
if d3 is None:
xms_bw = sd_taylor(xms, ds, v0=-v0)
xms_fw = sd_taylor(xms, ds, v0=+v0)
else:
xms_bw = sd_taylor(xms, ds, v0=-v0, v1=-v1)
xms_fw = sd_taylor(xms, ds, v0=+v0, v1=+v1)
return (xms, gms, Fms), (v0, v1), (xms_bw, xms_fw)
def set_EXE():
global EXE
# Defined in this file
if 'EXE' in globals():
return
# Try to export it from bashrc
elif KEYGAU in os.environ:
EXE = os.environ[KEYGAU]
return
# Not found
else: raise Exc.ExeNotDef(Exception)
def set_FCHK():
global FCHK
# Defined in this file
if 'FCHK' in globals():
return
# Try to export it from bashrc
elif KEYFCHK in os.environ:
FCHK = os.environ[KEYFCHK]
return
# Not found
else: raise Exc.ExeNotDef(Exception)
def read_path(filename=PN.IFILE3):
lines, status = file2lines(filename)
# Get info for lines
dpath = {}
ctc_lines = None
bool_mep = False
bool_drp = False
saveline = False
for line in lines:
#-- MEP --#
if line.startswith("end_mep"):
bool_mep = False
saveline = False
dpath[ctc] = ("mep", pathlines)
continue
#-- DRP --#
if line.startswith("end_drp"):
bool_drp = False
saveline = False
dpath[ctc] = ("drp", pathlines)
continue
# save line
if saveline: pathlines.append(line)
#-- MEP --#
if line.startswith("start_mep"):
bool_mep = True
saveline = True
ctc = line.split()[1]
pathlines = []
continue
#-- DRP --#
if line.startswith("start_drp"):
bool_drp = True
saveline = True
ctc = line.split()[1]
pathlines = []
continue
# Read data for each ctc
for ctc, (pathtype, lines) in dpath.items():
pathvars = PathVars(pathtype)
# Read info in lines
for line in lines:
line = line.lower()
key = line.split()[0]
value = " ".join(line.split()[1:]).lower()
try:
pathvars.setvar(key, value)
except:
exception = Exc.ReadProblem(Exception)
exception._file = filename
exception._var = line.split("\n")[0]
raise exception
dpath[ctc] = pathvars
return dpath, (filename, status)
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 read_gaussian_log(filename,target_level=None):
'''
xcc,gcc,Fcc and symbols --> returned without dummy atoms
'''
if not os.path.exists(filename): return
# split lines into blocks (in case of Link1)
blocks = split_gaulog_into_gaublocks(filename)
# Get info of each block
data = [get_data_from_gaublock(block) for block in blocks]
# There is nothing to return
if data == []: return [None]*12
# Localize data with hessian matrix
IDX = -1
for idx,data_i in enumerate(data):
Fcc = data_i[7]
if Fcc is not None:
IDX = idx
break
# Return the best set of data (the last with the hessian or the last block)
commands,comment,ch,mtp,symbols,xcc,gcc,Fcc,energies,E_oniom,num_imag,zmat = data[IDX]
# Recalculating xcc from z-matrix (do not trust the orientation read from output)
if zmat is not None:
(lzmat,zmatvals,zmatatoms),symbols = convert_zmat(zmat)
xcc = zmat2xcc(lzmat,zmatvals)
# Correct symbols (just in case)
symbols,atonums = symbols_and_atonums(symbols)
# Remove dummies from xcc, gcc and Fcc!
if xcc is not None: xcc = clean_dummies(symbols,xcc=xcc)[1]
if gcc is not None: gcc = clean_dummies(symbols,gcc=gcc)[1]
if Fcc is not None: Fcc = clean_dummies(symbols,Fcc=Fcc)[1]
symbols = clean_dummies(symbols)
# If user does not ask for level, send one of lowest energy
if target_level is None:
energies.sort()
energy,level = energies[0]
else:
IDX = None
exception = Exc.LevelNotFound()
exception._var = target_level
for idx,(energy,level) in enumerate(energies):
if level.lower() == target_level.lower():
IDX = idx
break
if IDX is None: raise exception
energy, level = energies[IDX]
# oniom?
if E_oniom is not None:
energy = E_oniom
level = "ONIOM"
# Return data
return commands,comment,ch,mtp,symbols,xcc,gcc,Fcc,energy,num_imag,zmat,level
def get_ratecons(rcs,dchem,dall,idx,temp):
drcons = dall.get("rcons",{})
processes = []
for key,(rctype,weight,coefs) in sorted(rcs.items()):
rctype = rctype.lower()
# reaction name and direction
if "." in key: rcname, direction = key.split(".")
else : rcname, direction = key, "both"
# elements in reaction
Rs,TS,Ps = dchem[rcname]
nR,nP = len(Rs),len(Ps)
# read/calculate rate constant
if "analytic" not in rctype:
key_fw = "%s.%s.%s"%(rctype,rcname,"fw")
key_bw = "%s.%s.%s"%(rctype,rcname,"bw")
# get rate constants
kfw = drcons.get(key_fw,None)
kbw = drcons.get(key_bw,None)
if kfw is not None: kfw = kfw[idx]
if kbw is not None: kbw = kbw[idx]
# any non-desired rate constants
if direction == "fw": kbw = None
if direction == "bw": kfw = None
# none
if kbw is None and kfw is None:
exception =Exc.NoRateCons(Exception)
exception._var = (rctype,key)
raise exception
else:
if rctype.lower() == "analytic1": k = log_anarc1(temp,*coefs)
elif rctype.lower() == "analytic2": k = log_anarc2(temp,*coefs)
elif rctype.lower() == "analytic3": k = log_anarc3(temp,*coefs)
elif rctype.lower() == "analytic4": k = log_anarc4(temp,*coefs)
elif rctype.lower() == "analytic5": k = log_anarc5(temp,*coefs)
else : k = None
# log --> exp
if k is not None: k = exp128(k)
# save data properly
if direction in ["fw","both"]: kfw, kbw = k , None
elif direction in ["bw" ]: kfw, kbw = None, k
else : kfw, kbw = None, None
# in atomic units
hunitsFW = ML**(nR-1.0) / SECOND
hunitsBW = ML**(nP-1.0) / SECOND
if kfw is not None: kfw /= hunitsFW
if kbw is not None: kbw /= hunitsBW
# ignore reactions giving rise to bimolecular products
if len(Ps) > 1 and direction != "bw": kbw = None
# save in processes
if kfw is not None: processes.append( (Rs,Ps,weight*kfw) )
if kbw is not None: processes.append( (Ps,Rs,weight*kbw) )
return processes
def compare_tcommon(tcommon, tcommon2, rstfile, eps=0.01):
exception = Exc.RstDiffVar(Exception)
exception._rst = rstfile
if tcommon2 is None: return
the_vars = ("ch", "mtp", "atonums", "masses", "mu")
for idx, var in enumerate(the_vars):
exception._var = var
var1, var2 = tcommon[idx], tcommon2[idx]
if type(var1) == type(1) or type(var1) == type(1.0):
var1 = [var1]
var2 = [var2]
for ii, jj in zip(var1, var2):
if abs(ii - jj) > eps: raise exception
def compare_tpath(tpath, tpath2, rstfile, eps=1e-8):
exception = Exc.RstDiffVar(Exception)
exception._rst = rstfile
if tpath2 is None: return
the_vars = ("method", "mu", "ds", "hsteps", "cubic")
for idx, var in enumerate(the_vars):
exception._var = var
var1, var2 = tpath[idx], tpath2[idx]
if type(var1) != type(var2): raise exception
if type(var1) == type(""):
if var1 != var2: raise exception
if type(var1) == type(1.0):
if abs(var1 - var2) > eps: raise exception
def execute(ifile,ofile,err,folder=None):
# Add folder to names
if folder is not None:
if not folder.endswith("/"): folder = folder + "/"
ifile = folder + ifile
ofile = folder + ofile
err = folder + err
# Execution file?
set_EXE()
check_EXE()
# Exception
exception = Exc.CalcFails(Exception)
exception._var = ofile
# Execute command
command = "%s %s 1>%s 2>%s"%(EXE,ifile,ofile,err)
try : status = os.system(command)
except: raise exception
return status
def prepare_dpath(dpath):
# Read data for each ctc
for ctc, (pathtype, lines) in dpath.items():
pathvars = PathVars(pathtype)
# Read info in lines
for line in lines:
line = line.lower()
key = line.split()[0]
value = " ".join(line.split()[1:]).lower()
try:
pathvars.setvar(key, value)
except:
exception = Exc.ReadProblem(Exception)
exception._file = filename
exception._var = line.split("\n")[0]
raise exception
dpath[ctc] = pathvars
return dpath
def genfchk(chk,fchk,err,folder=None):
# Add folder to names
if folder is not None:
if not folder.endswith("/"): folder = folder + "/"
chk = folder + chk
fchk = folder + fchk
err = folder + err
# fchk tool?
set_FCHK()
check_FCHK()
# Exception
exception = Exc.CalcFails(Exception)
exception._var = chk
# Execute fchk tool
command = "%s %s %s 1>%s 2>&1"%(FCHK,chk,fchk,err)
try : status = os.system(command)
except: raise exception
return status
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 highlevel_sp(ctc, itc, keyHL, gtsfile, software, dtesHL, dhighlvl):
# is calculation needed?
if keyHL in dhighlvl.keys(): return None
# folder for calculation and file name
TMP = PN.TMPHLi % keyHL
mname = "%s.%s" % (keyHL, "sp")
# Function for calculation and template
spc_fnc = get_spc_fnc(software)
tes = dtesHL.get(software, {}).get(ctc, None)
if tes is None: raise Exc.NoTemplateGiven(Exception)
# extra-arguments for spc_fnc
clean = False # do not delete files
bhess = False # do not calculate hessian (no needed actually)
eargs = (tes, TMP, clean)
# Read gts file (Molecule instance)
molecule = Molecule()
molecule.set_from_gts(gtsfile)
# HL-calculation
out_spc = spc_fnc(molecule._xcc, molecule._symbols, bhess, mname, eargs)
return out_spc[4]
def setup3(self):
'''
apply default value to those not defined!
'''
# use ics but no ics?
if self._useics == "yes" and (self._ics is None
or len(self._ics) == 0):
raise Exc.NoICS(Exception)
# path variables (via input) - advanced
if self._fwdir == "default": self._fwdir = None # ("1-2","++")
if self._cvt == "default": self._cvt = "yes"
if self._sct == "default": self._sct = "yes"
if self._mtype == "default": self._mtype = "pm"
if self._mu == "default": self._mu = 1.0 / AMU
if self._cubic == "default": self._cubic = "no"
if self._eref in ["default", "auto"]: self._eref = None
if self._paral == "default": self._paral = "no"
if self._epse == "default": self._epse = 1e-8
if self._epsg == "default": self._epsg = 1e-4
if self._useics == "default": self._useics = "yes"
if self._v1mode == "default": self._v1mode = "grad"
if self._scterr == "default": self._scterr = 0.0
if self._e0 in ["default", "auto"]: self._e0 = None
if self._lowfq == "default": self._lowfq = {}
if self._muintrpl == "default": self._muintrpl = ("linear", 0)
if self._qrc == "default": self._qrc = None
if self._onioml == "default": self._onioml = []
if self._oniomm == "default": self._oniomm = []
if self._oniomh == "default": self._oniomh = []
# setup parallel
self._paral = do_parallel(self._paral)
# setup cag
self.set_cag()
# useics = yes but there are no ics?
if self._useics == "yes" and (self._ics is None
or len(self._ics) == 0):
self._useics = "no"
def read_gaussian_log(filename, target_level=None):
if not os.path.exists(filename): return
# split lines into blocks (in case of Link1)
blocks = split_gaulog_into_gaublocks(filename)
# Get info of each block
data = [get_data_from_gaublock(block) for block in blocks]
# There is nothing to return
if data == []: return [None] * 12
# Localize data with hessian matrix
IDX = -1
for idx, data_i in enumerate(data):
Fcc = data_i[7]
if Fcc is not None:
IDX = idx
break
# Return the best set of data (the last with the hessian or the last block)
commands, comment, ch, mtp, symbols, xcc, gcc, Fcc, energies, E_oniom, num_imag, zmat = data[
IDX]
# If user does not ask for level, send one of lowest energy
if target_level is None:
energies.sort()
energy, level = energies[0]
else:
IDX = None
exception = Exc.LevelNotFound()
exception._var = target_level
for idx, (energy, level) in enumerate(energies):
if level.lower() == target_level.lower():
IDX = idx
break
if IDX is None: raise exception
energy, level = energies[IDX]
# oniom?
if E_oniom is not None:
energy = E_oniom
level = "ONIOM"
# Return data
return commands, comment, ch, mtp, symbols, xcc, gcc, Fcc, energy, num_imag, zmat, level
def set_EXE():
global EXE
txt = os.path.dirname(os.path.realpath(__file__))+"/paths.txt"
# Defined in this file
if 'EXE' in globals():
return
# Try to export it from bashrc
elif "OrcaExe" in os.environ:
# in .bashrc: export OrcaExe="$MYHOME/Software/orca_4_0_1_2/orca"
EXE = os.environ["OrcaExe"]
return
# Export it from file
elif os.path.exists(txt):
lines = read_file(txt)
lines = clean_lines(lines,"#",True)
for line in lines:
if line == "\n": continue
name, path = line.split()
if name == "orca":
EXE = path
return
# Not found
else: raise Exc.ExeNotDef(Exception)
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 check_FCHK():
if not os.path.exists(FCHK): raise Exc.ExeNotFound(Exception)
def check_EXE():
if not os.path.exists(EXE): raise Exc.ExeNotFound(Exception)
def read_gauout_old(gauout):
'''
Read Gaussian output (data in final message)
and return important data
'''
# check extension
end_out = (gauout.lower()).endswith(".out")
end_log = (gauout.lower()).endswith(".log")
if (not end_out) and (not end_log):
raise Exc.FileType(Exception)
# read lines
lines = read_file(gauout)
# CHECK FILE IS GAUSSIAN OUT
correct = False
for line in lines:
if "Entering Gaussian System" in line:
correct = True
break
if not correct: raise Exc.FileType(Exception)
# ONIOM energy?
try:
E_ONIOM = None
for line in lines[::-1]:
if "ONIOM: extrapolated energy" in line:
E_ONIOM = float(line.split()[-1])
break
except: E_ONIOM = None
# Get Forces if exists
key1 = "Forces (Hartrees/Bohr)"
key2 = "Cartesian Forces:"
try:
gcc = []
for line in extract_string(lines,key1,key2).split("\n")[3:-3]:
dummy, dummy, gx, gy, gz = line.split()
gcc += [float(gx),float(gy),float(gz)]
# forces to gradient
gcc = [-g_i for g_i in gcc]
except: gcc = None
if gcc == []: gcc = None
# Read string from gaussian output
DATA_LAST = []
DATA_WFCC = []
key1, key2 = "\GINC-","@"
strings = extract_string(lines,key1,key2,accumulate=True)
for string in strings:
lines = "".join([line.strip() for line in string.split()])
lines = lines.split("\\\\")
if lines == [""]: return None, None, None, None, None, None
# lines[3]: ch, mtp, symbols, xcc
str_geom = lines[3].split("\\")
ch , mtp = str_geom[0].split(",")
xcc = []
symbols = []
ch = int(ch)
mtp = int(mtp)
E = None
masses = []
for line in str_geom[1:]:
coords = line.split(",")
if len(coords) == 4:
symbol, x, y, z = line.split(",")
else:
symbol, tmp, x, y, z = line.split(",")
xcc += [float(x),float(y),float(z)]
symbols.append(symbol)
xcc = [xi/ANGSTROM for xi in xcc] # in bohr
# lines[4]: energy
E = float(lines[4].split("HF=")[1].split("\\")[0])
# Gradient
if gcc is None or len(gcc) == 0: gcc = [0.0 for x in xcc]
# Hessian
Fcc = []
for idx in range(len(lines)):
line = lines[idx]
if "NImag" not in line: continue
Fcc = [float(fij) for fij in lines[idx+1].split(",")]
# other lists
atonums = get_atonums(symbols)
masses = atonums2masses(atonums)
calclevel = ""
# Does it have hessian?
if Fcc != []: DATA_WFCC = [xcc, atonums, ch, mtp, E, gcc, Fcc, masses, calclevel]
# Save data
DATA_LAST = [xcc, atonums, ch, mtp, E, gcc, Fcc, masses, calclevel]
# Use ONIOM extrapolated energy if found!
if E_ONIOM is not None:
if len(DATA_WFCC) != 0: DATA_WFCC[4] = E_ONIOM
if len(DATA_LAST) != 0: DATA_LAST[4] = E_ONIOM
# return
if DATA_WFCC != []: return DATA_WFCC
else : return DATA_LAST
def read_fchk(fchkfile):
#------------------------#
# The labels to look for #
#------------------------#
labels = {} ; found_dict = {}
labels[0] = "Number of atoms" ; found_dict[0] = False
labels[1] = "Charge" ; found_dict[1] = False
labels[2] = "Multiplicity" ; found_dict[2] = False
labels[3] = "Total Energy" ; found_dict[3] = False
labels[4] = "Atomic numbers" ; found_dict[4] = False
labels[5] = "Current cartesian coordinates" ; found_dict[5] = False
labels[6] = "Real atomic weights" ; found_dict[6] = False
labels[7] = "Cartesian Gradient" ; found_dict[7] = False
labels[8] = "Cartesian Force Constants" ; found_dict[8] = False
# mandatory labels in fchk
idx_basic_labels = [0,1,2,3,4,5,6]
# initialization
natoms = None ; ch = None ; mtp = None ; E = None
atonums = [] ; masses = []
xcc = [] ; gcc = [] ; Fcc = []
# read file
lines = read_file(fchkfile)
# check extension
end_fchk = (fchkfile.lower()).endswith(".fchk")
if (not end_fchk): raise Exc.FileType(Exception)
# CHECK FILE IS FCHK
correct = False
for line in lines:
if line.startswith("Current cartesian coordinates "):
correct = True
break
if not correct: raise Exc.FileType(Exception)
# Get level of calculation
calclevel = " ".join(lines[1].split()[1:])
# get data from lines
for idx in range(len(lines)):
line = lines[idx]
# Number of atoms
if line.startswith(labels[0]):
found_dict[0] = True
natoms = int(line.split()[-1])
# Charge
elif line.startswith(labels[1]):
found_dict[1] = True
ch = int(line.split()[-1])
# Spin multiplicity
elif line.startswith(labels[2]):
found_dict[2] = True
mtp = int(line.split()[-1])
# Total Energy
elif line.startswith(labels[3]):
found_dict[3] = True
E = float(line.split()[-1])
# Atomic Numbers
elif line.startswith(labels[4]):
found_dict[4] = True
length = int(line.split()[-1])
idx2 = idx+1
while len(atonums) != length:
nextline = lines[idx2]
atonums += [int(i) for i in nextline.split()]
idx2 += 1
# Cartesian Coordinates
elif line.startswith(labels[5]):
found_dict[5] = True
length = int(line.split()[-1])
idx2 = idx+1
while len(xcc) != length:
nextline = lines[idx2]
xcc += [float(i) for i in nextline.split()]
idx2 += 1
# List of atomic masses
elif line.startswith(labels[6]):
found_dict[6] = True
length = int(line.split()[-1])
idx2 = idx+1
while len(masses) != length:
nextline = lines[idx2]
masses += [float(i) for i in nextline.split()]
idx2 += 1
# Cartesian Gradient
elif line.startswith(labels[7]) and natoms != 1:
found_dict[7] = True
length = int(line.split()[-1])
idx2 = idx+1
while len(gcc) != length:
nextline = lines[idx2]
gcc += [float(i) for i in nextline.split()]
idx2 += 1
# Cartesian Force Constant Matrix
elif line.startswith(labels[8]) and natoms != 1:
found_dict[8] = True
length = int(line.split()[-1])
idx2 = idx+1
while len(Fcc) != length:
nextline = lines[idx2]
Fcc += [float(fij) for fij in nextline.split()]
idx2 += 1
# Return data
#if gcc == []: gcc = None
#if Fcc == []: Fcc = None
return xcc,atonums,ch,mtp,E,gcc,Fcc,masses, calclevel.strip()
def read_orcaout(orca_out):
# Read lines
lines = read_file(orca_out)
# CHECK FILE IS ORCA OUT
correct = False
for line in lines:
if "This ORCA versions uses" in line:
correct = True
break
if not correct: raise Exc.FileType(Exception)
# Initialize
ch, mtp, E = None, None, None
xcc, symbols, atonums = [], [], []
# basis set
basisset = ""
try:
for line in lines:
if "utilizes the basis" in line:
basisset = line.split(":")[1]
break
except:
pass
# hamiltonian
hamiltonian = ""
try:
for idx, line in enumerate(lines):
if "Hamiltonian:" in line:
hamiltonian = lines[idx + 1].split()[-1]
break
except:
pass
# level of calculation
calclevel = hamiltonian + " " + basisset
# Get ch, mtp, E
pos_cart = None
pos_zmat = None
for idx in range(len(lines)):
line = lines[idx]
if "Total Charge Charge" in line: ch = int(line.split()[-1])
if "Multiplicity Mult" in line: mtp = int(line.split()[-1])
if "FINAL SINGLE POINT ENERGY " in line: E = float(line.split()[-1])
if "CARTESIAN COORDINATES (A.U.)" in line: pos_cart = idx
if "INTERNAL COORDINATES (ANGST" in line: pos_zmat = idx
# Get xcc, symbols, atonums
if pos_cart is None:
sys.exit(
"Unable to find 'CARTESIAN COORDINATES (A.U.)' label in file!")
pos_cart += 3
for line in lines[pos_cart:]:
line = line.strip()
if line == "": break
idx, symbol, atonum, dummy, mass, x, y, z = line.split()
if symbol == "-": symbol = "XX"
xcc += [float(x), float(y), float(z)]
symbols.append(symbol)
atonums.append(int(atonum.split(".")[0]))
# data in internal coordinates
lzmat = None
if pos_zmat is not None:
pos_zmat += 2
lzmat = []
for idx, line in enumerate(lines[pos_zmat:]):
line = line.strip()
if line == "": break
symbol, atk, atj, ati, dist, angle, dihedral = line.split()
if symbol == "-": symbol = "XX"
atk, atj, ati = int(atk) - 1, int(atj) - 1, int(ati) - 1
dist, angle, dihedral = float(dist), float(angle), float(dihedral)
if idx == 0: connections, values = (), ()
elif idx == 1: connections, values = (atk, ), (dist, )
elif idx == 2: connections, values = (atk, atj), (dist, angle)
else:
connections, values = (atk, atj, ati), (dist, angle, dihedral)
data = (symbol, connections, values)
lzmat += [data]
# Return
return xcc, lzmat, atonums, ch, mtp, E, calclevel.strip()
def path2vadi(tcommon,drst,Eref=None,ics=None,boolint=False,lowfq={},freqscal=1.0,icsbw=None,icsfw=None,symmetry=None):
'''
lowfq: in case of imaginary frequencies
'''
# boolint as boolean
if boolint in [False,"no","No","n","N",None]: boolint = False
elif boolint in [True,"yes","YES","y","Y"] : boolint = True
# check there are internal coordinates if required
if boolint and ics in [None,False,[]]: raise Exc.NoICS(Exception)
# expand data in tcommon
ch,mtp,atnums,masses,mu = tcommon
# Sorted labels (by s)
slabels = sd.sorted_points(drst,hess=True)
# Reference energy
if Eref is None: lbw, lfw, sbw, sfw, Eref, Efw = sd.rstlimits(drst)
# Independent variable
data_x = [drst[label][0] for label in slabels]
# mep energy (relative value)
listV0 = [drst[label][1]-Eref for label in slabels]
# Initializing data
lcc_tzpe, lcc_frqs, lcc_Vadi = [], [], []
lic_tzpe, lic_frqs, lic_Vadi = [], [], []
dMols = {}
# Updating data
for label in slabels:
# data in drst
s_i, E_i, xms_i,gms_i,Fms_i,v0_i,v1_i,t_i = drst[label]
# project gradient
if s_i == 0.0: bool_pg = False
else : bool_pg = True
# lowfq
if s_i == 0.0: dlowfq = {}
elif s_i < 0.0: dlowfq = lowfq.get("bw",{})
elif s_i > 0.0: dlowfq = lowfq.get("fw",{})
# mass-scaled --> Cartesian coords
xcc = fncs.ms2cc_x(xms_i,masses,mu)
gcc = fncs.ms2cc_g(gms_i,masses,mu)
Fcc = fncs.ms2cc_F(Fms_i,masses,mu)
# create Molecule instance
mol = Molecule()
mol.setvar(xcc=xcc,gcc=gcc,Fcc=Fcc)
mol.setvar(atonums=atnums,masses=masses)
mol.setvar(ch=ch,mtp=mtp,V0=E_i)
mol.setvar(fscal=freqscal)
if symmetry is not None:
mol.setvar(pgroup=symmetry[0])
mol.setvar(rotsigma=symmetry[1])
mol.prepare()
mol.setup(mu,projgrad=bool_pg)
mol.clean_freqs("cc") # it may be needed with orca
mol.deal_lowfq(dlowfq,"cc") # deal with low frequencies
mol.ana_freqs("cc") # calculate zpe
# append data
lcc_tzpe.append(float(mol._cczpe) )
lcc_Vadi.append(mol._ccV1 - Eref )
lcc_frqs.append(list(mol._ccfreqs))
# internal coordinates
if boolint:
if s_i < 0.0 and icsbw is not None: mol.icfreqs(icsbw,bool_pg)
elif s_i > 0.0 and icsfw is not None: mol.icfreqs(icsfw,bool_pg)
else : mol.icfreqs(ics ,bool_pg)
mol.deal_lowfq(dlowfq,"ic")
mol.ana_freqs("ic")
# append data
lic_tzpe.append(float(mol._iczpe) )
lic_Vadi.append(mol._icV1 - Eref )
lic_frqs.append(list(mol._icfreqs))
# save instance
dMols[label] = (s_i,mol)
# package data
tuple_cc = (data_x,lcc_frqs,lcc_tzpe)
tuple_ic = (data_x,lic_frqs,lic_tzpe)
# Generate splines
Vadi_cc = VadiSpline(data_x,lcc_Vadi)
if boolint: Vadi_ic = VadiSpline(data_x,lic_Vadi)
else : Vadi_ic = None
# Return data
return dMols, Vadi_cc, Vadi_ic, tuple_cc, tuple_ic, listV0
def pilgrim_spc(xcc, symbols, bhessian, mname, eargs):
# expand extra-args
if len(eargs) == 1:
spc_template = eargs[0]
folder, clean = None, False
elif len(eargs) == 2:
spc_template, folder = eargs
clean = False
elif len(eargs) == 3:
spc_template, folder, clean = eargs
elif len(eargs) == 5:
spc_template, folder, clean, frozen, oniom_layers = eargs
# no template??
if spc_template is None: raise Exc.NoTemplateGiven(Exception)
# create folder
if folder is not None:
if not os.path.exists(folder): os.mkdir(folder)
# Calculate gradient&hessian or just gradient
if bhessian: inkey3 = "! EnGrad Freq "
else: inkey3 = "! EnGrad "
# names of files
wname, ifile, ofile, engrad, hess, gbw, err = ITF.iofiles(mname, folder)
# Input
string_ifile = ""
for line in spc_template.split("\n"):
if key1 in line:
line = ""
for idx, symbol in enumerate(symbols):
x, y, z = fncs.xyz(xcc, idx)
linedata = (symbol, x * pc.ANGSTROM, y * pc.ANGSTROM,
z * pc.ANGSTROM)
line += "%2s %+11.6f %+11.6f %+11.6f\n" % linedata
if key2 in line:
pos = line.find(key2)
line = line[0:pos] + wname + line[pos + len(key2):]
if key3 in line:
pos = line.find(key3)
line = line[0:pos] + inkey3 + line[pos + len(key3):]
# Add \n to line
if not line.endswith("\n"): line += "\n"
string_ifile += line
ff.write_file(ifile, string_ifile)
# Send calculation
status = ITF.execute(ifile, ofile, err)
# # Sleep 0.5 seconds, so Orca can write the files
# time.sleep(0.5)
# Check output
exception = Exc.CalcFails(Exception)
exception._var = ofile
if not ITF.normal_termination(ofile): raise exception
# Read data
xcc, atonums, ch, mtp, E, gcc, Fcc, masses, clevel = ff.read_orca(ofile)
# Remove files
if clean:
files = os.listdir(folder)
files = [fff for fff in files if fff.startswith(name)]
files = [fff for fff in files if not fff.endswith(".inp")]
files = [fff for fff in files if not fff.endswith(".out")]
files = [fff for fff in files if not fff.endswith(".engrad")]
files = [fff for fff in files if not fff.endswith(".hess")]
for fff in files:
os.remove(folder + fff)
return xcc, atonums, ch, mtp, E, gcc, Fcc, masses
