def readfile_xyz(fname):
string = ""
zmat, symbols, masses = ff.read_xyz_zmat(fname)
xcc = intl.zmat2xcc(zmat[0],zmat[1])
# Print more information
ndummy = symbols.count("XX")
natoms = len(symbols)-ndummy
# without dummies
symbols_wo , xcc_wo = fncs.clean_dummies(symbols,xcc=xcc)
symbols_wo , masses_wo = fncs.clean_dummies(symbols,masses=masses)
molecule = Molecule()
molecule.setvar(xcc=xcc_wo,symbols=symbols_wo,masses=masses_wo,ch=0,mtp=1)
molecule.prepare()
molecule.setup()
string += "Molecular formula : %s\n"%molecule._mform
string += "Number of atoms : %i\n"%natoms
string += "Number of dummy atoms : %i\n"%ndummy
string += "Vibrational d.o.f. : %i\n"%molecule._nvdof
string += "\n"
# Cartesian Coordinates
string += "Cartesian coordinates (in Angstrom):\n"
sidx = "%%%si"%len(str(len(symbols)))
at_wo = -1
dwithout = {}
for at,symbol in enumerate(symbols):
xi,yi,zi = [value*pc.ANGSTROM for value in xcc[3*at : 3*at+3]]
mass = masses[at]*pc.AMU
datainline = (sidx%(at+1),symbol,xi,yi,zi,mass)
if symbol != "XX": at_wo += 1; dwithout[at] = at_wo
else: dwithout[at] = None
string += "[%s] %-2s %+12.7f %+12.7f %+12.7f (%7.3f amu)\n"%datainline
string += "\n"
return xcc,zmat,symbols,masses,(dwithout,molecule,natoms,ndummy),string
def generate_gts_file(esfile, gtsfile, read_method):
'''
Generate gts file (and molden & frozen files)
from given electronic structure (ES) file;
The ES file is read using read_method
'''
# Extra files that (maybe) will be generated
file_frozen = gtsfile + ".frozen" # only if any frozen atom
file_molden = gtsfile + ".molden" # molden file
# read file
xcc, atonums, ch, mtp, E, gcc, Fcc, masses, clevel = read_method(
PN.UFOLDER + esfile)[0:9]
# clevel is not really clevel when using read_gtsfile as read_method
if read_method == read_gtsfile: clevel = ""
# symbols and atonums
symbols, atonums = fncs.symbols_and_atonums(atonums)
# is masses available?
if masses is None or len(masses) == 0 or sum(masses) == 0.0:
masses = atonums2masses(atonums)
# is Fcc available?
if len(atonums) != 1 and (Fcc is None or len(Fcc) == 0):
status = -1
cache = None
molec = None
else:
# Generate Molecule instance
molec = Molecule()
molec.setvar(xcc=xcc, gcc=gcc, Fcc=Fcc)
molec.setvar(atonums=atonums, masses=masses)
molec.setvar(ch=ch, mtp=mtp, V0=E)
molec.prepare()
# Deal with frozen atoms [atom i is frozen if Fij=0 forall j)
frozen_xcc, frozen_symbols = molec.remove_frozen()
# Calculate point group (must be done after remove frozen)
molec.calc_pgroup(force=True)
# Deal with Hessian
molec.setup()
# write gts file
molec.genfile_gts(PN.DIR1 + gtsfile, level=clevel)
status = 1
# write frozen (if there are frozen atoms)
RW.write_frozen(PN.DIR1 + file_frozen, frozen_xcc, frozen_symbols)
# write molden file
idata = (PN.DIR1 + file_molden, molec._xcc, molec._symbols,
molec._ccfreqs, molec._ccFevecs)
write_molden(*idata)
# save to cache
nimag = int(fncs.numimag(molec._ccfreqs))
pgroup = str(molec._pgroup)
mform = str(molec._mform)
cache = [esfile, gtsfile, E, ch, mtp, nimag, mform, pgroup]
# delete variable, just in case
del xcc, gcc, Fcc
del symbols, atonums, masses
del molec
# return
return status, cache
def get_ts_ifreq(xcc, gcc, Fcc, E, tcommon):
ch, mtp, atonums, masses, mu = tcommon
ts = Molecule()
ts.setvar(xcc=xcc, gcc=gcc, Fcc=Fcc)
ts.setvar(atonums=atonums, masses=masses)
ts.setvar(ch=ch, mtp=mtp, V0=E)
ts.prepare()
ts.setup(mu)
ts.ana_freqs()
[(ifreq, evec)] = ts._ccimag
return ifreq, mu
def log_data(log, inpvars, fscal, folder="./"):
if inpvars._ts: fmode = -1
else: fmode = 0
# name from log
name = log.split(".")[-2]
point = TorPESpoint(name, inpvars._tlimit)
# Read log file
logdata = gau.read_gaussian_log(folder + log)
# prepare data
logdata = prepare_log_data(logdata)
ch, mtp, V0, symbols, symbols_wo, xcc_wo, gcc_wo, Fcc_wo, lzmat, zmatvals = logdata
# string for fccards
string_fccards = gau.get_fccards_string(gcc_wo, Fcc_wo)
# generate Molecule instance
molecule = Molecule()
molecule.setvar(xcc=xcc_wo, Fcc=Fcc_wo, V0=V0)
molecule.setvar(fscal=fscal)
molecule.setvar(symbols=symbols_wo)
molecule.setvar(ch=ch, mtp=mtp)
molecule.prepare()
molecule.setup()
molecule.ana_freqs()
# Calculate partition functions for the temperatures
qtot, V1, qis = molecule.calc_pfns(inpvars._temps, fmode=fmode)
qtr, qrot, qvib, qele = qis
Qrv = np.array([xx * yy for xx, yy in zip(qrot, qvib)])
# Calculate partition functions at target temperature
qtot, V1, qis = molecule.calc_pfns([inpvars._temp], fmode=fmode)
# remove rotsigma for Gibbs
gibbs = V1 - pc.KB * inpvars._temp * np.log(qtot[0] * molecule._rotsigma)
# imaginary frequency
if len(molecule._ccimag) == 0: ifreq = None
elif len(molecule._ccimag) == 1:
ifreq = [ifreq for ifreq, ivec in list(molecule._ccimag)][0]
else:
ifreq = None
# weight for this conformer
if inpvars._enantio and molecule._pgroup.lower() == "c1": weight = 2
else: weight = 1
# pack and return data
conf_tuple = (point, V0, V1, gibbs, weight, Qrv, ifreq, lzmat, zmatvals,
log)
return conf_tuple, symbols, string_fccards
def get_rotcons(lzmat,zmatvals,symbols):
xcc = zmat2xcc(lzmat,zmatvals)
# correct symbols (just in case)
symbols,atonums = fncs.symbols_and_atonums(symbols)
# Data without dummies
symbols_wo,xcc_wo = fncs.clean_dummies(symbols,xcc=list(xcc))
# generate Molecule instance
molecule = Molecule()
molecule.setvar(xcc=xcc_wo)
molecule.setvar(symbols=symbols_wo)
molecule.setvar(V0=0)
molecule.setvar(ch=0,mtp=1)
molecule.prepare()
molecule.setup()
# in freq units (GHz)
imoms = [Ii * pc.KG*pc.METER**2 for Ii in molecule._imoms]
rotcons = [pc.H_SI/(Ii*8*np.pi**2)/1E9 for Ii in imoms]
return rotcons
def userfile_to_gtsfile(filename, gtsfile):
'''
Read a file given by the user and generate gts file
if possible
'''
gtsfile = gtsname(gtsfile, "full")
read_methods = []
read_methods.append(read_gtsfile) #(a) a gts file
read_methods.append(read_fchk) #(b) a fchk file
read_methods.append(read_gauout_v1) #(c.1) a Gaussian output file (ramos)
read_methods.append(read_gauout_v2) #(c.2) a Gaussian output file (ferro)
read_methods.append(read_orca) #(d) an Orca output file
for read_method in read_methods:
try:
xcc, atonums, ch, mtp, E, gcc, Fcc, masses, clevel = read_method(
filename)[0:9]
if read_method == read_gtsfile: clevel = ""
# in case no data in masses
if masses is None or len(masses) == 0 or sum(masses) == 0.0:
masses = atonums2masses(atonums)
# Some checking
if len(atonums) != 1 and Fcc in ([], None):
#raise Exc.FccNotFound
return -1, None
# Generate Molecule instance
molecule = Molecule()
molecule.setvar(xcc=xcc, gcc=gcc, Fcc=Fcc)
molecule.setvar(atonums=atonums, masses=masses)
molecule.setvar(ch=ch, mtp=mtp, V0=E)
molecule.prepare()
# Deal with frozen atoms
ffrozen = gtsfile + ".frozen"
frozen_xcc, frozen_symbols = molecule.remove_frozen()
RW.write_frozen(ffrozen, frozen_xcc, frozen_symbols)
# write gts
molecule.calc_pgroup(force=True)
molecule.genfile_gts(gtsfile, level=clevel)
return 1, E
except Exc.FileType:
continue
except:
continue
return 0, None
def get_imag_freq(log, fscal):
try:
# Read log file
logdata = gau.read_gaussian_log(log)
logdata = prepare_log_data(logdata)
ch, mtp, V0, symbols, symbols_wo, xcc_wo, gcc_wo, Fcc_wo, lzmat, zmatvals = logdata
# diagonalize Fcc
molecule = Molecule()
molecule.setvar(xcc=xcc_wo, Fcc=Fcc_wo, V0=V0)
molecule.setvar(fscal=fscal)
molecule.setvar(symbols=symbols_wo)
molecule.setvar(ch=ch, mtp=mtp)
molecule.prepare()
molecule.setup()
molecule.ana_freqs()
ifreq = molecule._ccimag[0][0]
except:
ifreq = None
# return
return ifreq
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