def readTurbomoleBasis(path):
"""Read Turbomole basis set"""
bss = topParseB.parseFile(path)
atoms = [xs.atomLabel.lower() for xs in bss]
names = concat([xs.basisName.upper().split() for xs in bss])
formats = [xs.format[:] for xs in bss]
formats_int = map(lambda fss: [[int(x) for x in xs] for xs in fss], formats)
rss = [rs.coeffs[:] for rs in bss]
rawData = [[x.contractions[:] for x in rss[i]] for i in range(len(rss))]
fst = lambda xs: xs[0]
snd = lambda xs: xs[1]
expos = list(
map(
mapFloat,
[concatMap(fst, swapCoeff(2, rawData[i])) for i in range(len(rawData))],
)
)
coeffs = list(
map(
mapFloat,
[concatMap(snd, swapCoeff(2, rawData[i])) for i in range(len(rawData))],
)
)
basisData = zipWith(AtomBasisData)(expos)(coeffs)
basiskey = zipWith3(AtomBasisKey)(atoms)(names)(formats_int)
return basiskey, basisData
def createAtoms(xs):
"""
Create an AtomXYZ tuple from a string.
"""
ls = [a.label.lower() for a in xs]
rs = [list(map(float, a.xyz)) for a in xs]
return zipWith(AtomXYZ)(ls)(rs)
def test_zipwith():
"""
zipWith f xs ys == map (f) (zip xs ys)
"""
@curry
def f(x, y):
return x * y
xs = range(3)
ys = range(3, 6)
assert zipWith(f)(xs)(ys) == [f(x, y) for (x, y) in zip(xs, ys)]
def readCp2KBasis(path):
"""
Read the Contracted Gauss function primitives format from a text file.
:param path: Path to the file containing the basis.
:type path: String
"""
bss = topParseBasis.parseFile(path)
atoms = ["".join(xs.atom[:]).lower() for xs in bss]
names = [" ".join(xs.basisName[:]).upper() for xs in bss]
formats = [list(map(int, xs.format[:])) for xs in bss]
# for example 2 0 3 7 3 3 2 1 there are sum(3 3 2 1) =9 Lists
# of Coefficients + 1 lists of exponents
nCoeffs = [int(sum(xs[4:]) + 1) for xs in formats]
rss = zipWith(swapCoeff2)(nCoeffs)(list(map(float, cs.coeffs[:]))
for cs in bss)
tss = [headTail(xs) for xs in rss]
basisData = [AtomBasisData(xs[0], xs[1]) for xs in tss]
basiskey = zipWith3(AtomBasisKey)(atoms)(names)(formats)
return (basiskey, basisData)
def saveMO(self,
parserFun,
pathMO,
nOrbitals=None,
nOrbFuns=None,
pathEs=None,
pathCs=None,
nOccupied=None,
nHOMOS=None,
nLUMOS=None):
"""
Save Molecular orbital eigenvalues and eigenvectors.
:parameter parserFun: Function to parse the file containing the MOs.
:parameter pathMO: Absolute path to the MOs file.
:type pathMO: String
:parameter nOrbitals: Number of orbitals
:type nOrbitals: Int
:param nOrbFuns: Number of Atomic orbitals function that made up
each of the molecular orbitals.
:type nOrbFuns: Int
:parameter pathEs: Path to the MO eigenvalues in the HDF5 file
(default is: <softwareName>/mo/eigenvalues).
:type pathEs: String
:parameter pathCs: Path to the MO coefficients in the HDF5 file
(default is: <softwareName>/mo/coefficients).
:type pathCs: String
:param nOccupied: Number of occupied molecular orbitals.
:type nOccupied: Int
:param nHOMOS: number of H**O orbitals to store in HDF5.
:type nHOMOS: Int
:param nLUMOS: number of HUMO orbitals to store in HDF5.
:type nLUMOS: Int
:returns: **None**
"""
pathEs = pathEs if pathEs is not None else join(
self.name, "mo", "eigenvalues")
pathCs = pathCs if pathCs is not None else join(
self.name, "mo", "coefficients")
# Save all the frontier orbitals.
# NOTE: IT ASSUMES THAT The USER HAVE SELECTED A RANGE OF MO
# TO PRINT.
if not (nHOMOS is None and nLUMOS is None):
infoMO = parserFun(pathMO, nHOMOS + nLUMOS, nOrbFuns)
elif nOrbitals is not None:
infoMO = parserFun(pathMO, nOrbitals, nOrbFuns)
if not (nHOMOS is None and nLUMOS is None) and \
nOrbitals > nHOMOS + nLUMOS:
# Drop Coefficients that below and above nHOMOS and nLUMOS,
# respectively.
ess, css = infoMO
css = np.transpose(css)
eigenVals = ess[nOccupied - nHOMOS:nOccupied + nLUMOS]
coefficients = css[nOccupied - nHOMOS:nOccupied + nLUMOS]
infoMO = InfoMO(eigenVals, np.transpose(coefficients))
zipWith(self.funHDF5)([pathEs,
pathCs])([infoMO.eigenVals, infoMO.coeffs])
