Source code for psi4.driver.qcdb.vib

#
# @BEGIN LICENSE
#
# Psi4: an open-source quantum chemistry software package
#
# Copyright (c) 2007-2024 The Psi4 Developers.
#
# The copyrights for code used from other parties are included in
# the corresponding files.
#
# This file is part of Psi4.
#
# Psi4 is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, version 3.
#
# Psi4 is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with Psi4; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# @END LICENSE
#

import collections
import itertools
import math
import sys
from typing import Dict, List, Tuple, Union

import numpy as np
from qcelemental import Datum

import psi4  # for typing

from .constants import constants
from .libmintsmolecule import compute_atom_map

LINEAR_A_TOL = 1.0E-2  # tolerance (roughly max dev) for TR space

__all__ = ["compare_vibinfos", "filter_nonvib", "filter_omega_to_real", "harmonic_analysis", "hessian_symmetrize", "print_molden_vibs", "print_vibs", "thermo"]


[docs] def compare_vibinfos(expected: Dict[str, Datum], computed: Dict[str, Datum], tol: float, label: str, verbose: int = 1, forgive: List = None, required: List = None, toldict: Dict[str, float] = None) -> bool: """Returns True if two dictionaries of vibration Datum objects are equivalent within a tolerance. Parameters ---------- expected Reference value against which `computed` is compared. computed Input value to compare against `expected`. Must contain all fields of `expected`. tol Absolute tolerance. label Label for passed and error messages. verbose Control printing. forgive Keys in top level which may change between `expected` and `computed` without triggering failure. required Keys in top level which must be present in `computed`. ("omega" recc. for vibs.) toldict Tolerances for specific keys. Returns ------- allclose : bool Returns True if `expected` and `computed` are equal within tolerance; False otherwise. """ np.set_printoptions(formatter={'float': '{: 0.4f}'.format}) def _success(label): """Function to print a '*label*...PASSED' line to screen. Used by :py:func:`util.compare_values` family when functions pass. """ msg = f'\t{label:.<66}PASSED' print(msg) sys.stdout.flush() def print_stuff(asp, same, ref, val, space=''): if verbose >= 1: print(asp, ':', same) if (verbose >= 2) or (not same and verbose >= 1): print('\texp:', space, ref) print('\tobs:', space, val) if verbose >= 1: if not same: try: print('\tdif:', space, val - ref) except TypeError: print('\tdif: Different, inspect arrays') if forgive is None: forgive = [] summsame = [] if required is None: checkkeys = [] else: checkkeys = required checkkeys.extend(expected.keys()) svdtol = 1.e-6 if toldict is None else toldict.get("svd", 1.e-6) for asp in checkkeys: if asp not in computed and asp in forgive: continue if toldict is not None and asp in toldict: ktol = toldict[asp] else: ktol = tol if asp in 'qwx': ccnc = _phase_cols_to_max_element(computed[asp].data) eenc = _phase_cols_to_max_element(expected[asp].data) ccnc = _check_degen_modes(ccnc, computed['omega'].data) eenc = _check_degen_modes(eenc, expected['omega'].data) same = np.allclose(eenc, ccnc, atol=ktol) print_stuff(asp=asp, same=same, ref=eenc, val=ccnc, space='\n') same = _check_rank_degen_modes(ccnc, computed["omega"].data, eenc, difftol=ktol, svdtol=svdtol) elif asp in ['gamma', 'TRV']: same = all([computed[asp].data[idx] == val for idx, val in enumerate(expected[asp].data)]) print_stuff(asp=asp, same=same, ref=expected[asp].data, val=computed[asp].data) elif isinstance(expected[asp].data, float): same = abs(expected[asp].data - computed[asp].data) < ktol print_stuff(asp=asp, same=same, ref=expected[asp].data, val=computed[asp].data) else: same = (np.allclose(expected[asp].data, computed[asp].data, atol=ktol) and (expected[asp].data.shape == computed[asp].data.shape)) print_stuff(asp=asp, same=same, ref=expected[asp].data, val=computed[asp].data) if asp not in forgive: summsame.append(same) passed = all(summsame) if passed: _success(label) return passed
[docs] def hessian_symmetrize(hess: np.ndarray, mol: psi4.core.Molecule) -> np.ndarray: """Apply Abelian symmetry of `mol` to Hessian `hess`. Parameters ---------- hess (3 * nat, 3 * nat) Hessian array perhaps with jitter unbecoming a symmetric molecule. mol Molecule at which Hessian computed. Returns ------- numpy.ndarray (3 * nat, 3 * nat) symmetrized Hessian array. """ ct = mol.point_group().char_table() # Obtain atom mapping of atom * symm op to atom atom_map = compute_atom_map(mol) syms = [] smap = [] for g in range(ct.order()): syms.append(np.asarray(ct.symm_operation(g).d)) smap.append([atom_map[at][g] for at in range(mol.natom())]) np.set_printoptions(formatter={'float': '{: 16.12f}'.format}) b_hess = blockwise_expand(hess, (3, 3), False) bDG = [] nat = b_hess.shape[0] for iat in range(nat): for jat in range(nat): for sym in range(len(syms)): bDG.append(np.zeros_like(b_hess)) bDG[sym][iat, jat] = syms[sym].dot(b_hess[iat, jat].dot(syms[sym])) # Note that tested syms all diagonal, so above may be off by some transposes for sym in range(len(syms)): bDG[sym] = bDG[sym][:, smap[sym]] bDG[sym] = bDG[sym][smap[sym], :] tot = np.sum(bDG, axis=0) tot = np.divide(tot, len(syms)) print('symmetrization diff:', np.linalg.norm(tot - b_hess)) m_tot = blockwise_contract(tot) return m_tot
def _check_rank_degen_modes(arr, freq, ref, difftol, svdtol, verbose=1): dfreq, didx, dinv, dcts = np.unique(np.around(freq, 1), return_index=True, return_inverse=True, return_counts=True) normco_ok = True for idegen, istart in enumerate(didx): degree = dcts[idegen] cvecs = arr[:, istart:istart + degree] evecs = ref[:, istart:istart + degree] cevecs = np.concatenate((cvecs, evecs), axis=1) diff_ok = np.allclose(evecs, cvecs, atol=difftol) rank_cvecs = np.linalg.matrix_rank(cvecs) rank_evecs = np.linalg.matrix_rank(evecs) CE = np.linalg.svd(cevecs, compute_uv=False) # hermitian=False rank_cevecs = np.count_nonzero(CE > svdtol, axis=-1) # expected normal coordinates and computed normal coordinates span the same space ranks_ok = rank_cvecs == rank_evecs == rank_cevecs if degree == 1: normco_ok = normco_ok and diff_ok else: normco_ok = normco_ok and ranks_ok if verbose >= 2 or not normco_ok: with np.printoptions(precision=4): print(f"degree={degree} difftol={difftol} {diff_ok} svdtol={svdtol} {rank_cvecs} == {rank_evecs} == {rank_cevecs} {rank_cvecs == rank_evecs == rank_cevecs} svd={CE}") return normco_ok def _check_degen_modes(arr, freq, verbose=1): """Use `freq` to identify degenerate columns of eigenvectors `arr` and sort into std order for comparison. Returns eigenvectors back sorted. """ arr2 = np.zeros_like(arr) # lgtm [py/multiple-definition] dfreq, didx, dinv, dcts = np.unique(np.around(freq, 1), return_index=True, return_inverse=True, return_counts=True) # judging degen normco to only 2 decimals is probably sign need to resolve evec idx_max_elem_each_normco = np.argmax(np.around(arr, 2), axis=0) max_elem_each_normco = np.amax(np.around(arr, 2), axis=0) idx_vib_reordering = np.empty_like(idx_max_elem_each_normco) for idegen, istart in enumerate(didx): degree = dcts[idegen] # sort degen evec # primarily (last arg) by value of extreme element # (sep evec that in this coord sys have diff elements) # & secondarily (2nd-to-last arg) by index of extreme element # (order evec with same elements in diff (xyz) arrangements) idx_sort_wi_degen = np.lexsort( (idx_max_elem_each_normco[istart:istart + degree], max_elem_each_normco[istart:istart + degree])) idx_vib_reordering[istart:istart + degree] = np.arange(istart, istart + degree)[idx_sort_wi_degen] arr2 = arr[:, idx_vib_reordering] reorderings = ['{}-->{}'.format(i, v) for i, v in enumerate(idx_vib_reordering) if (i != v)] if reorderings and verbose >= 2: print('Degenerate modes reordered:', ', '.join(reorderings)) return arr2 def _phase_cols_to_max_element(arr, tol=1.e-2, verbose=1): """Returns copy of 2D `arr` scaled such that, within cols, max(fabs) element is positive. If max(fabs) is pos/neg pair, scales so first element (within `tol`) is positive. """ arr2 = np.copy(arr) rephasing = [] for v in range(arr.shape[1]): vextreme = 0.0 iextreme = None # find most extreme value for varr in arr[:, v]: vextreme = max(np.absolute(varr), vextreme) # find the first index whose fabs equals that value, w/i tolerance for iarr, varr in enumerate(arr[:, v]): if (vextreme - np.absolute(varr)) < tol: iextreme = iarr break sign = np.sign(arr[iextreme, v]) if sign == -1.: rephasing.append(str(v)) arr2[:, v] *= sign if rephasing and verbose >= 2: print('Negative modes rephased:', ', '.join(rephasing)) return arr2
[docs] def harmonic_analysis(hess: np.ndarray, geom: np.ndarray, mass: np.ndarray, basisset: psi4.core.BasisSet, irrep_labels: List[str], dipder: np.ndarray = None, project_trans: bool = True, project_rot: bool = True) -> Tuple[Dict[str, Datum], str]: """Extract frequencies, normal modes and other properties from electronic Hessian. Like so much other Psi4 goodness, originally by @andysim Parameters ---------- hess (3*nat, 3*nat) non-mass-weighted Hessian in atomic units, [Eh/a0/a0]. geom (nat, 3) geometry [a0] at which Hessian computed. mass (nat,) atomic masses [u]. basisset Basis set object (can be dummy, e.g., STO-3G) for SALCs. irrep_labels Irreducible representation labels. dipder (3, 3 * nat) dipole derivatives in atomic units, [Eh a0/u] or [(e a0/a0)^2/u] project_trans Idealized translations projected out of final vibrational analysis. project_rot Idealized rotations projected out of final vibrational analysis. Returns ------- dict, str Returns dictionary of vibration Datum objects (fields: label units data comment). Also returns text suitable for printing. Notes ----- .. _`table:vibaspectinfo`: +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | key | description (label & comment) | units | data (real/imaginary modes) | +===============+============================================+===========+======================================================+ | omega | frequency | cm^-1 | ndarray(ndof) complex (real/imag) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | q | normal mode, normalized mass-weighted | a0 u^1/2 | ndarray(ndof, ndof) float | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | w | normal mode, un-mass-weighted | a0 | ndarray(ndof, ndof) float | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | x | normal mode, normalized un-mass-weighted | a0 | ndarray(ndof, ndof) float | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | degeneracy | degree of degeneracy | | ndarray(ndof) int | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | TRV | translation/rotation/vibration | | ndarray(ndof) str 'TR' or 'V' or '-' for partial | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | gamma | irreducible representation | | ndarray(ndof) str irrep or None if unclassifiable | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | mu | reduced mass | u | ndarray(ndof) float (+/+) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | k | force constant | mDyne/A | ndarray(ndof) float (+/-) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | DQ0 | RMS deviation v=0 | a0 u^1/2 | ndarray(ndof) float (+/0) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | Qtp0 | Turning point v=0 | a0 u^1/2 | ndarray(ndof) float (+/0) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | Xtp0 | Turning point v=0 | a0 | ndarray(ndof) float (+/0) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | theta_vib | char temp | K | ndarray(ndof) float (+/0) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ | IR_intensity | infrared intensity | km/mol | ndarray(ndof) float (+/+) | +---------------+--------------------------------------------+-----------+------------------------------------------------------+ Examples -------- >>> # displacement of first atom in highest energy mode >>> vibinfo['x'].data[:, -1].reshape(nat, 3)[0] >>> # remove translations & rotations >>> vibonly = filter_nonvib(vibinfo) """ if (mass.shape[0] == geom.shape[0] == (hess.shape[0] // 3) == (hess.shape[1] // 3)) and (geom.shape[1] == 3): pass else: raise ValidationError( f"""Dimension mismatch among mass ({mass.shape}), geometry ({geom.shape}), and Hessian ({hess.shape})""") def mat_symm_info(a, atol=1e-14, lbl='array', stol=None): symm = np.allclose(a, a.T, atol=atol) herm = np.allclose(a, a.conj().T, atol=atol) ivrt = a.shape[0] - np.linalg.matrix_rank(a, tol=stol) return """ {:32} Symmetric? {} Hermitian? {} Lin Dep Dim? {:2}""".format(lbl + ':', symm, herm, ivrt) def vec_in_space(vec, space, tol=1.0e-4): merged = np.vstack((space, vec)) u, s, v = np.linalg.svd(merged) return (s[-1] < tol) vibinfo = {} text = [] nat = len(mass) text.append("""\n\n ==> Harmonic Vibrational Analysis <==\n""") if nat == 1: nrt_expected = 3 elif np.linalg.matrix_rank(geom) == 1: nrt_expected = 5 else: nrt_expected = 6 nmwhess = hess.copy() text.append(mat_symm_info(nmwhess, lbl='non-mass-weighted Hessian') + ' (0)') # get SALC object, possibly w/o trans & rot mints = psi4.core.MintsHelper(basisset) cdsalcs = mints.cdsalcs(0xFF, project_trans, project_rot) Uh = collections.OrderedDict() for h, lbl in enumerate(irrep_labels): tmp = np.asarray(cdsalcs.matrix_irrep(h)) if tmp.size > 0: Uh[lbl] = tmp # form projector of translations and rotations space = ('T' if project_trans else '') + ('R' if project_rot else '') TRspace = _get_TR_space(mass, geom, space=space, tol=LINEAR_A_TOL) nrt = TRspace.shape[0] text.append( f' projection of translations ({project_trans}) and rotations ({project_rot}) removed {nrt} degrees of freedom ({nrt_expected})' ) P = np.identity(3 * nat) for irt in TRspace: P -= np.outer(irt, irt) text.append(mat_symm_info(P, lbl='total projector') + f' ({nrt})') # mass-weight & solve sqrtmmm = np.repeat(np.sqrt(mass), 3) sqrtmmminv = np.divide(1.0, sqrtmmm) mwhess = np.einsum('i,ij,j->ij', sqrtmmminv, nmwhess, sqrtmmminv) text.append(mat_symm_info(mwhess, lbl='mass-weighted Hessian') + ' (0)') pre_force_constant_au = np.linalg.eigvalsh(mwhess) idx = np.argsort(pre_force_constant_au) pre_force_constant_au = pre_force_constant_au[idx] uconv_cm_1 = (np.sqrt(constants.na * constants.hartree2J * 1.0e19) / (2 * np.pi * constants.c * constants.bohr2angstroms)) pre_frequency_cm_1 = np.lib.scimath.sqrt(pre_force_constant_au) * uconv_cm_1 pre_lowfreq = np.where(np.real(pre_frequency_cm_1) < 100.0)[0] pre_lowfreq = np.append(pre_lowfreq, np.arange(nrt_expected)) # catch at least nrt modes for lf in set(pre_lowfreq): vlf = pre_frequency_cm_1[lf] if vlf.imag > vlf.real: text.append(' pre-proj low-frequency mode: {:9.4f}i [cm^-1]'.format(vlf.real, vlf.imag)) else: text.append(' pre-proj low-frequency mode: {:9.4f} [cm^-1]'.format(vlf.real, '')) text.append(' pre-proj all modes:' + str(_format_omega(pre_frequency_cm_1, 4))) # project & solve mwhess_proj = np.dot(P.T, mwhess).dot(P) text.append(mat_symm_info(mwhess_proj, lbl='projected mass-weighted Hessian') + f' ({nrt})') #print('projhess = ', np.array_repr(mwhess_proj)) force_constant_au, qL = np.linalg.eigh(mwhess_proj) # expected order for vibrations is steepest downhill to steepest uphill idx = np.argsort(force_constant_au) force_constant_au = force_constant_au[idx] qL = qL[:, idx] qL = _phase_cols_to_max_element(qL) vibinfo['q'] = Datum('normal mode', 'a0 u^1/2', qL, comment='normalized mass-weighted') # frequency, LAB II.17 frequency_cm_1 = np.lib.scimath.sqrt(force_constant_au) * uconv_cm_1 vibinfo['omega'] = Datum('frequency', 'cm^-1', frequency_cm_1) # degeneracies ufreq, uinv, ucts = np.unique(np.around(frequency_cm_1, 1), return_inverse=True, return_counts=True) vibinfo['degeneracy'] = Datum('degeneracy', '', ucts[uinv]) # look among the symmetry subspaces h for one to which the normco # of vib does *not* add an extra dof to the vector space active = [] irrep_classification = [] for idx, vib in enumerate(frequency_cm_1): if vec_in_space(qL[:, idx], TRspace, 1.0e-4): active.append('TR') irrep_classification.append(None) else: active.append('V') for h in Uh.keys(): if vec_in_space(qL[:, idx], Uh[h], 1.0e-4): irrep_classification.append(h) break else: irrep_classification.append(None) # catch partial Hessians if np.linalg.norm(vib) < 1.e-3: active[-1] = '-' vibinfo['TRV'] = Datum('translation/rotation/vibration', '', active, numeric=False) vibinfo['gamma'] = Datum('irreducible representation', '', irrep_classification, numeric=False) lowfreq = np.where(np.real(frequency_cm_1) < 100.0)[0] lowfreq = np.append(lowfreq, np.arange(nrt_expected)) # catch at least nrt modes for lf in set(lowfreq): vlf = frequency_cm_1[lf] if vlf.imag > vlf.real: text.append(' post-proj low-frequency mode: {:9.4f}i [cm^-1] ({})'.format(vlf.imag, active[lf])) else: text.append(' post-proj low-frequency mode: {:9.4f} [cm^-1] ({})'.format(vlf.real, active[lf])) text.append(' post-proj all modes:' + str(_format_omega(frequency_cm_1, 4)) + '\n') if project_trans and not project_rot: text.append(f' Note that "Vibration"s include {nrt_expected - 3} un-projected rotation-like modes.') elif not project_trans and not project_rot: text.append( f' Note that "Vibration"s include {nrt_expected} un-projected rotation-like and translation-like modes.') # general conversion factors, LAB II.11 uconv_K = (constants.h * constants.na * 1.0e21) / (8 * np.pi * np.pi * constants.c) uconv_S = np.sqrt((constants.c * (2 * np.pi * constants.bohr2angstroms)**2) / (constants.h * constants.na * 1.0e21)) # normco & reduced mass, LAB II.14 & II.15 wL = np.einsum('i,ij->ij', sqrtmmminv, qL) vibinfo['w'] = Datum('normal mode', 'a0', wL, comment='un-mass-weighted') reduced_mass_u = np.divide(1.0, np.linalg.norm(wL, axis=0)**2) vibinfo['mu'] = Datum('reduced mass', 'u', reduced_mass_u) xL = np.sqrt(reduced_mass_u) * wL vibinfo['x'] = Datum('normal mode', 'a0', xL, comment='normalized un-mass-weighted') # IR intensities, CCQC Proj. Eqns. 15-16 uconv_kmmol = (constants.get("Avogadro constant") * np.pi * 1.e-3 * constants.get("electron mass in u") * constants.get("fine-structure constant")**2 * constants.get("atomic unit of length") / 3) uconv_D2A2u = (constants.get('atomic unit of electric dipole mom.') * 1.e11 / constants.get('hertz-inverse meter relationship') / constants.get('atomic unit of length'))**2 if not (dipder is None or np.array(dipder).size == 0): qDD = dipder.dot(wL) ir_intensity = np.zeros(qDD.shape[1]) for i in range(qDD.shape[1]): ir_intensity[i] = qDD[:, i].dot(qDD[:, i]) # working but not needed #vibinfo['IR_intensity'] = Datum('infrared intensity', 'Eh a0/u', ir_intensity) #ir_intensity_D2A2u = ir_intensity * uconv_D2A2u #vibinfo['IR_intensity'] = Datum('infrared intensity', '(D/AA)^2/u', ir_intens_D2A2u) ir_intensity_kmmol = ir_intensity * uconv_kmmol vibinfo['IR_intensity'] = Datum('infrared intensity', 'km/mol', ir_intensity_kmmol) # force constants, LAB II.16 (real compensates for earlier sqrt) uconv_mdyne_a = (0.1 * (2 * np.pi * constants.c)**2) / constants.na force_constant_mdyne_a = reduced_mass_u * (frequency_cm_1 * frequency_cm_1).real * uconv_mdyne_a vibinfo['k'] = Datum('force constant', 'mDyne/A', force_constant_mdyne_a) force_constant_cm_1_bb = reduced_mass_u * (frequency_cm_1 * frequency_cm_1).real * uconv_S * uconv_S Datum('force constant', 'cm^-1/a0^2', force_constant_cm_1_bb, comment="Hooke's Law") # turning points, LAB II.20 (real & zero since turning point silly for imag modes) nu = 0 turning_point_rnc = np.sqrt(2.0 * nu + 1.0) with np.errstate(divide='ignore'): turning_point_bohr_u = turning_point_rnc / (np.sqrt(frequency_cm_1.real) * uconv_S) turning_point_bohr_u[turning_point_bohr_u == np.inf] = 0. vibinfo['Qtp0'] = Datum('Turning point v=0', 'a0 u^1/2', turning_point_bohr_u) with np.errstate(divide='ignore'): turning_point_bohr = turning_point_rnc / (np.sqrt(frequency_cm_1.real * reduced_mass_u) * uconv_S) turning_point_bohr[turning_point_bohr == np.inf] = 0. vibinfo['Xtp0'] = Datum('Turning point v=0', 'a0', turning_point_bohr) rms_deviation_bohr_u = turning_point_bohr_u / np.sqrt(2.0) vibinfo['DQ0'] = Datum('RMS deviation v=0', 'a0 u^1/2', rms_deviation_bohr_u) # characteristic vibrational temperature, RAK thermo & https://en.wikipedia.org/wiki/Vibrational_temperature # (imag freq zeroed) uconv_K = 100 * constants.h * constants.c / constants.kb vib_temperature_K = frequency_cm_1.real * uconv_K vibinfo['theta_vib'] = Datum('char temp', 'K', vib_temperature_K) return vibinfo, '\n'.join(text)
def _br(string): return '[' + string + ']' def _format_omega(omega, decimals): """Return complex frequencies in `omega` into strings showing only real or imag ("i"-labeled) to `decimals` precision. """ freqs = [] for fr in omega: if fr.imag > fr.real: freqs.append("""{:.{prec}f}i""".format(fr.imag, prec=decimals)) else: freqs.append("""{:.{prec}f}""".format(fr.real, prec=decimals)) return np.array(freqs)
[docs] def thermo(vibinfo, T: float, P: float, multiplicity: int, molecular_mass: float, E0: float, sigma: int, rot_const: np.ndarray, rotor_type: str = None) -> Tuple[Dict[str, Datum], str]: """Perform thermochemical analysis from vibrational output. Parameters ---------- E0 Electronic energy [Eh] at well bottom at 0 [K], :psivar:`CURRENT ENERGY`. molecular_mass Mass in [u] of molecule under analysis. multiplicity Spin multiplicity of molecule under analysis. rot_const (3,) rotational constants in [cm^-1] of molecule under analysis. sigma The rotational or external symmetry number determined from the point group. rotor_type The rotor type for rotational stat mech purposes: RT_ATOM, RT_LINEAR, other. T Temperature in [K]. Psi default 298.15. Note that 273.15 is IUPAC STP. P Pressure in [Pa]. Psi default 101325. Note that 100000 is IUPAC STP. Returns ------- dict, str First is every thermochemistry component in atomic units along with input conditions. Second is formatted presentation of analysis. """ sm = collections.defaultdict(float) # conditions therminfo = {} therminfo['E0'] = Datum('E0', 'Eh', E0) therminfo['B'] = Datum('rotational constants', 'cm^-1', rot_const) therminfo['sigma'] = Datum('external symmetry number', '', sigma) therminfo['T'] = Datum('temperature', 'K', T) therminfo['P'] = Datum('pressure', 'Pa', P) # electronic q_elec = multiplicity sm[('S', 'elec')] = math.log(q_elec) # translational beta = 1 / (constants.kb * T) q_trans = (2.0 * np.pi * molecular_mass * constants.amu2kg / (beta * constants.h * constants.h))**1.5 * constants.na / (beta * P) sm[('S', 'trans')] = 5 / 2 + math.log(q_trans / constants.na) sm[('Cv', 'trans')] = 3 / 2 sm[('Cp', 'trans')] = 5 / 2 sm[('E', 'trans')] = 3 / 2 * T sm[('H', 'trans')] = 5 / 2 * T # rotational if rotor_type == "RT_ATOM": pass elif rotor_type == "RT_LINEAR": q_rot = 1. / (beta * sigma * 100 * constants.c * constants.h * rot_const[1]) sm[('S', 'rot')] = 1.0 + math.log(q_rot) sm[('Cv', 'rot')] = 1 sm[('Cp', 'rot')] = 1 sm[('E', 'rot')] = T else: phi_A, phi_B, phi_C = rot_const * 100 * constants.c * constants.h / constants.kb q_rot = math.sqrt(math.pi) * T**1.5 / (sigma * math.sqrt(phi_A * phi_B * phi_C)) sm[('S', 'rot')] = 3 / 2 + math.log(q_rot) sm[('Cv', 'rot')] = 3 / 2 sm[('Cp', 'rot')] = 3 / 2 sm[('E', 'rot')] = 3 / 2 * T sm[('H', 'rot')] = sm[('E', 'rot')] # vibrational vibonly = filter_nonvib(vibinfo) ZPE_cm_1 = 1 / 2 * np.sum(vibonly['omega'].data.real) omega_str = _format_omega(vibonly['omega'].data, decimals=4) imagfreqidx = np.where(vibonly['omega'].data.imag > vibonly['omega'].data.real)[0] if len(imagfreqidx): print("Warning: thermodynamics relations excluded imaginary frequencies: {}".format(omega_str[imagfreqidx])) filtered_theta_vib = np.delete(vibonly['theta_vib'].data, imagfreqidx, None) filtered_omega_str = np.delete(omega_str, imagfreqidx, None) rT = filtered_theta_vib / T # reduced temperature lowfreqidx = np.where(filtered_theta_vib < 900.)[0] if len(lowfreqidx): print("Warning: used thermodynamics relations inappropriate for low-frequency modes: {}".format( filtered_omega_str[lowfreqidx])) sm[('S', 'vib')] = np.sum(rT / np.expm1(rT) - np.log(1 - np.exp(-rT))) sm[('Cv', 'vib')] = np.sum(np.exp(rT) * (rT / np.expm1(rT))**2) sm[('Cp', 'vib')] = sm[('Cv', 'vib')] sm[('ZPE', 'vib')] = np.sum(rT) * T / 2 sm[('E', 'vib')] = sm[('ZPE', 'vib')] + np.sum(rT * T / np.expm1(rT)) sm[('H', 'vib')] = sm[('E', 'vib')] assert (abs(ZPE_cm_1 - sm[('ZPE', 'vib')] * constants.R * constants.hartree2wavenumbers * 0.001 / constants.hartree2kJmol) < 0.1) #real_vibs = np.ma.masked_where(vibinfo['omega'].data.imag > vibinfo['omega'].data.real, vibinfo['omega'].data) # compute Gibbs for term in ['elec', 'trans', 'rot', 'vib']: sm[('G', term)] = sm[('H', term)] - T * sm[('S', term)] # convert to atomic units for term in ['elec', 'trans', 'rot', 'vib']: # terms above are unitless (S, Cv, Cp) or in units of temperature (ZPE, E, H, G) as expressions are divided by R. # R [Eh/K], computed as below, slightly diff in 7th sigfig from 3.1668114e-6 (k_B in [Eh/K]) # value listed https://en.wikipedia.org/wiki/Boltzmann_constant uconv_R_EhK = constants.R / constants.hartree2kJmol for piece in ['S', 'Cv', 'Cp']: sm[(piece, term)] *= uconv_R_EhK # [mEh/K] <-- [] for piece in ['ZPE', 'E', 'H', 'G']: sm[(piece, term)] *= uconv_R_EhK * 0.001 # [Eh] <-- [K] # sum corrections and totals for piece in ['S', 'Cv', 'Cp']: for term in ['elec', 'trans', 'rot', 'vib']: sm[(piece, 'tot')] += sm[(piece, term)] for piece in ['ZPE', 'E', 'H', 'G']: for term in ['elec', 'trans', 'rot', 'vib']: sm[(piece, 'corr')] += sm[(piece, term)] sm[(piece, 'tot')] = E0 + sm[(piece, 'corr')] terms = collections.OrderedDict() terms['elec'] = ' Electronic' terms['trans'] = ' Translational' terms['rot'] = ' Rotational' terms['vib'] = ' Vibrational' terms['tot'] = 'Total' terms['corr'] = 'Correction' # package results for export for entry in sm: if entry[0] in ['S', 'Cv', 'Cp']: unit = 'mEh/K' elif entry[0] in ['ZPE', 'E', 'H', 'G']: unit = 'Eh' therminfo['_'.join(entry)] = Datum(terms[entry[1]].strip().lower() + ' ' + entry[0], unit, sm[entry]) # display format_S_Cv_Cp = """\n {:36} {:11.3f} [cal/(mol K)] {:11.3f} [J/(mol K)] {:15.8f} [mEh/K]""" format_ZPE_E_H_G = """\n {:36} {:11.3f} [kcal/mol] {:11.3f} [kJ/mol] {:15.8f} [Eh]""" uconv = np.asarray([constants.hartree2kcalmol, constants.hartree2kJmol, 1.]) # TODO rot_const, rotor_type text = '' text += """\n ==> Thermochemistry Components <==""" text += """\n\n Entropy, S""" for term in terms: text += format_S_Cv_Cp.format(terms[term] + ' S', *sm[('S', term)] * uconv) if term == 'elec': text += """ (multiplicity = {})""".format(multiplicity) elif term == 'trans': text += """ (mol. weight = {:.4f} [u], P = {:.2f} [Pa])""".format(molecular_mass, P) elif term == 'rot': text += """ (symmetry no. = {})""".format(sigma) text += """\n\n Constant volume heat capacity, Cv""" for term in terms: text += format_S_Cv_Cp.format(terms[term] + ' Cv', *sm[('Cv', term)] * uconv) text += """\n\n Constant pressure heat capacity, Cp""" for term in terms: text += format_S_Cv_Cp.format(terms[term] + ' Cp', *sm[('Cp', term)] * uconv) del terms['tot'] terms['corr'] = 'Correction' text += """\n\n ==> Thermochemistry Energy Analysis <==""" text += """\n\n Raw electronic energy, E_e""" text += f"""\n Total E_e, Electronic energy at well bottom {E0:15.8f} [Eh]""" text += """\n\n Zero-point vibrational energy, ZPVE = Sum_i omega_i / 2, E_0 = E_e + ZPVE""" for term in terms: if term in ['vib']: text += format_ZPE_E_H_G.format(terms[term] + ' ZPVE', *sm[('ZPE', term)] * uconv) text += """ {:15.3f} [cm^-1]""".format(sm[('ZPE', term)] * constants.hartree2wavenumbers) elif term in ['corr']: text += format_ZPE_E_H_G.format(terms[term] + ' ZPVE to E_e', *sm[('ZPE', term)] * uconv) text += """ {:15.3f} [cm^-1]""".format(sm[('ZPE', term)] * constants.hartree2wavenumbers) text += """\n Total E_0, Enthalpy at 0 [K] {:15.8f} [Eh]""".format( sm[('ZPE', 'tot')]) text += """\n *** Absolute enthalpy, not an enthalpy of formation ***""" text += """\n\n Thermal (internal) energy, E (includes ZPVE and finite-temperature corrections)""" for term in terms: if term in ['elec']: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to E beyond E_e', *sm[('E', term)] * uconv) elif term in ['corr']: text += format_ZPE_E_H_G.format(terms[term] + ' E', *sm[('E', term)] * uconv) else: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to E', *sm[('E', term)] * uconv) text += """\n Total E, Thermal (internal) energy at {:7.2f} [K] {:15.8f} [Eh]""".format( T, sm[('E', 'tot')]) text += """\n\n Enthalpy, H_trans = E_trans + k_B * T = E_trans + P * V""" for term in terms: if term in ['elec']: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to H beyond E_e', *sm[('H', term)] * uconv) elif term in ['corr']: text += format_ZPE_E_H_G.format(terms[term] + ' H', *sm[('H', term)] * uconv) else: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to H', *sm[('H', term)] * uconv) text += """\n Total H, Enthalpy at {:7.2f} [K] {:15.8f} [Eh]""".format( T, sm[('H', 'tot')]) text += """\n *** Absolute enthalpy, not an enthalpy of formation ***""" text += """\n\n Gibbs free energy, G = H - T * S""" for term in terms: if term in ['elec']: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to G beyond E_e', *sm[('G', term)] * uconv) elif term in ['corr']: text += format_ZPE_E_H_G.format(terms[term] + ' G', *sm[('G', term)] * uconv) else: text += format_ZPE_E_H_G.format(terms[term] + ' contrib to G', *sm[('G', term)] * uconv) text += """\n Total G, Gibbs energy at {:7.2f} [K] {:15.8f} [Eh]""".format( T, sm[('G', 'tot')]) text += """\n *** Absolute Gibbs energy, not a free energy of formation ***\n\n""" return therminfo, text
[docs] def filter_nonvib(vibinfo: Dict[str, Datum], remove: List[int] = None) -> Dict[str, Datum]: """From a dictionary of vibration Datum, remove normal coordinates. Parameters ---------- vibinfo Results of Hessian analysis. remove 0-indexed indices of normal modes to remove from `vibinfo`. If None, non-vibrations (R, T, or TR as labeled in `vibinfo['TRV']`) will be removed. Returns ------- dict Copy of input `vibinfo` with the specified modes removed from all dictionary entries. Examples -------- >>> # after a harmonic analysis, remove first translations and rotations and then all non-A1 vibs >>> allnormco = harmonic_analysis(...) >>> allvibs = filter_nonvib(allnormco) >>> a1vibs = filter_nonvib(allvibs, remove=[i for i, d in enumerate(allvibs['gamma'].data) if d != 'A1']) """ work = {} if remove is None: remove = [idx for idx, dat in enumerate(vibinfo['TRV'].data) if dat != 'V'] for asp, oasp in vibinfo.items(): if asp in ['q', 'w', 'x']: axis = 1 else: axis = 0 work[asp] = Datum(oasp.label, oasp.units, np.delete(oasp.data, remove, axis=axis), comment=oasp.comment, numeric=False) return work
[docs] def filter_omega_to_real(omega: np.ndarray) -> np.ndarray: """Returns ndarray (float) of `omega` (complex) where imaginary entries are converted to negative reals.""" freqs = [] for fr in omega: if fr.imag > fr.real: freqs.append(-1 * fr.imag) else: freqs.append(fr.real) return np.asarray(freqs)
def _get_TR_space(m: np.ndarray, geom: np.ndarray, space: str = 'TR', tol: float = None, verbose: int = 1) -> np.ndarray: """Form the idealized translation and rotation dof from geometry `geom` and masses `m`. Remove any linear dependencies and return an array of shape (3, 3) for atoms, (5, 3 * nat) for linear `geom`, or (6, 3 * nat) otherwise. To handle noisy linear geometries, pass `tol` on the order of max deviation. m1 = np.asarray([1.]) m2 = np.asarray([1., 1.]) m3 = np.asarray([1., 1., 1.]) m4 = np.asarray([1., 1., 1., 1.]) g4 = np.asarray([[ 1., 1., 0.], [-1., 1., 0.], [-1., -1., 0.], [ 1., -1., 0.]]) g2 = np.asarray([[ 1., 1., 0.], [-1., -1., 0.]]) g3 = np.asarray([[3., 3., 3.], [4., 4., 4.,], [5., 5., 5.]]) g3noisy = np.asarray([[3., 3.001, 3.], [4., 4.001, 4.,], [5., 5., 5.01]]) g33 = np.asarray([[0., 0., 0.], [1., 0., 0.], [-1., 0., 0.]]) g1 = np.asarray([[0., 0., 0.]]) g11 = np.asarray([[1., 2., 3.]]) noise = np.random.normal(0, 1, 9).reshape(3, 3) noise = np.divide(noise, np.max(noise)) assert(_get_TR_space(m4, g4).shape == (6, 12)) assert(_get_TR_space(m2, g2).shape == (5, 6)) assert(_get_TR_space(m3, g3).shape == (5, 9)) assert(_get_TR_space(m3, g33).shape == (5, 9)) assert(_get_TR_space(m1, g1).shape == (3, 3)) assert(_get_TR_space(m1, g11).shape == (3, 3)) assert(_get_TR_space(m3, g3noisy, tol=1.e-2).shape == (5, 9)) for ns in range(2, 6): tol = 10. ** -ns gnoisy = g3 + tol * noise assert(_get_TR_space(m3, gnoisy, tol=10*tol).shape == (5, 9)) """ sqrtmmm = np.repeat(np.sqrt(m), 3) xxx = np.repeat(geom[:, 0], 3) yyy = np.repeat(geom[:, 1], 3) zzz = np.repeat(geom[:, 2], 3) z = np.zeros_like(m) i = np.ones_like(m) ux = np.ravel([i, z, z], order='F') uy = np.ravel([z, i, z], order='F') uz = np.ravel([z, z, i], order='F') # form translation and rotation unit vectors T1 = sqrtmmm * ux T2 = sqrtmmm * uy T3 = sqrtmmm * uz R4 = sqrtmmm * (yyy * uz - zzz * uy) R5 = sqrtmmm * (zzz * ux - xxx * uz) R6 = sqrtmmm * (xxx * uy - yyy * ux) TRspace = [] if 'T' in space: TRspace.append([T1, T2, T3]) if 'R' in space: TRspace.append([R4, R5, R6]) if not TRspace: # not sure about this, but it runs ZZ = np.zeros_like(T1) TRspace.append([ZZ]) TRspace = np.vstack(TRspace) def orth(A, tol=tol): u, s, vh = np.linalg.svd(A, full_matrices=False) if verbose >= 2: print(s) M, N = A.shape eps = np.finfo(float).eps if tol is None: tol = max(M, N) * np.amax(s) * eps num = np.sum(s > tol, dtype=int) Q = u[:, :num] return Q TRindep = orth(TRspace.T) TRindep = TRindep.T if verbose >= 2: print(TRindep.shape, '<--', TRspace.shape) print(np.linalg.norm(TRindep, axis=1)) print('-' * 80) return TRindep