mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/wavefunction/multipole.py

@@ -0,0 +1,159 @@
+# [1] https://doi.org/10.1063/1.4937410
+#     The consequences of improperly describing oscillator strengths
+#     beyond the electric dipole approximation
+#     Lestrange, Egidi, Li, 2015
+# [2] https://doi.org/10.1016/0009-2614(95)01036-9
+#     Ab initio calculation and display of the rotary strength tensor in
+#     the random phase approximation. Method and model studies.
+#     Pedersen, Hansen, 1995
+
+from typing import List, Optional
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+def get_multipole_moment(
+    order: int,
+    coords3d: NDArray[float],
+    origin: NDArray[float],
+    multipole_ints: NDArray[float],
+    nuc_charges: NDArray[int],
+    P: NDArray[float],
+) -> NDArray[float]:
+    """
+    order
+        Kind of requested multipoles: (1, dipole moment), (2, quadrupole moment).
+    coords3d
+        Cartesian coordinates of shape (natoms, 3).
+    origin
+        Origin of the multipole expansion. The supplied integrales must
+        be calculated w.r.t. this origin.
+    multipole_ints
+        Linear or quadratic multipole moment integrals.
+    nuc_charges
+        Nuclear charges.
+    P
+        Density matrix in the AO basis.
+    """
+    origin = np.array(origin, dtype=float)
+    assert origin.size == 3
+    assert len(coords3d) == len(nuc_charges)
+
+    # Make a copy, as the coordinates must be give w.r.t. the origin, which
+    # may be != (0., 0., 0.).
+    coords3d = coords3d.copy()
+    coords3d -= origin[None, :]
+
+    electronic = np.einsum("...ij,ji->...", multipole_ints, P)
+    if order == 1:
+        nuclear = np.einsum("i,ix->x", nuc_charges, coords3d)
+    elif order == 2:
+        nuclear = np.einsum("i,ix,iy->xy", nuc_charges, coords3d, coords3d)
+    else:
+        raise Exception(f"Multipoles of order={order} are not implemented!")
+    moment = nuclear - electronic
+    return moment
+
+
+def get_transition_multipole_moment(
+    multipole_ints: NDArray[float],
+    C_a: NDArray[float],
+    C_b: NDArray[float],
+    T_a: NDArray[float],
+    T_b: NDArray[float] = None,
+    occ_a: Optional[int] = None,
+    occ_b: Optional[int] = None,
+    full: bool = False,
+) -> List[NDArray[float]]:
+    """
+    Transition multipole moments from transition density matrices.
+
+    This functions relies on the following normalization
+
+        closed shell: 0.5 = norm(X_a)**2 - norm(Y_a)**2
+          open shell: 1.0 = norm(X_a,X_b)**2 - norm(Y_a,Y_b)**2
+
+    with X_a,X_b indicating a vector formed by concatenating the elements
+    of X_a and X_b for every state. See also Eq. (33) in [1].
+
+    Parameters
+    ----------
+    multipole_integrals
+        Multipole integrals in the AO basis of the desired ordered,
+        e.g., linear moment for transition dipole moments or quadratic
+        moments for quadrupole transition moments.
+    C_a
+        MO-coefficients for α-electrons.
+    C_b
+        MO-coefficients for β-electrons.
+    T_a
+        Numpy array containing transition density matrices of shape
+        (nstates, occ, virt) or (occ, virt) in the α-electron space.
+        The transition density must be given in the MO-basis!
+    T_b
+        See P_a. Optional. If not provided, P_b is derived from P_a.
+    occ_a
+        Number of α-electrons.
+    occ_b
+        Number of β-electrons.
+    full
+        Use all MOs to transform multipole integrals. Needed for state-to-state
+        transition denstiy matrices of shape (occ+virt, occ+virt).
+
+    Returns
+    -------
+    trans_moments
+        Transition moments of the respective order for all provided
+        states.
+    """
+
+    # Deal with unrestricted transition density matrices that contain
+    # only one state.
+    def atleast_3d(tden):
+        if tden.ndim == 2:
+            tden = tden[None, :]
+        return tden
+
+    T_a = atleast_3d(T_a)
+    if T_b is not None:
+        T_b = atleast_3d(T_b)
+    # Expected shape: (nstates, occ, virt)
+    assert T_a.ndim == 3
+    if not full:
+        assert occ_a is not None
+
+    def get_trans_moment(
+        C: NDArray[float], occ: int, T: NDArray[float]
+    ) -> NDArray[float]:
+        # Transform AO integrals to MO basis.
+        # Excited state to excited state transition densities will span all
+        # molecular orbitals.
+        if full:
+            C_occ = C
+            C_virt = C
+        # Ground state to excited state transition density matrices will be
+        # of shape (occ, virt).
+        else:
+            C_occ = C[:, :occ]
+            C_virt = C[:, occ:]
+        multipole_ints_mo = np.einsum(
+            "jl,...lm,mk->...jk", C_occ.T, multipole_ints, C_virt, optimize="greedy",
+        )
+
+        """
+        Then contract with multipole integrals. For TDMs see Eq. (18) in [2].
+        i : Excited state number
+        j : occ. MO space
+        k : virt. MO space
+        """
+        trans_moment = np.einsum("...jk,ijk->i...", multipole_ints_mo, T, optimize="greedy")
+        return trans_moment
+
+    # Transitions between α -> α and β -> β
+    trans_moment = get_trans_moment(C_a, occ_a, T_a)
+    if T_b is None:
+        trans_moment *= 2
+    else:
+        trans_moment += get_trans_moment(C_b, occ_b, T_b)
+    return trans_moment

pysisyphus/wavefunction/normalization.py

@@ -0,0 +1,36 @@
+from math import prod
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.special import factorial2
+
+from pysisyphus.wavefunction.helpers import canonical_order
+
+
+# @functools.cache
+def get_lmn_factors(L: int):
+    lmns = canonical_order(L)
+    lmn_factors = np.zeros(len(lmns))
+    for i, lmn in enumerate(lmns):
+        lmn_factors[i] = prod([factorial2(2 * am - 1) for am in lmn])
+    lmn_factors = 1 / np.sqrt(lmn_factors)
+    return lmn_factors
+
+
+def norm_cgto_lmn(coeffs: NDArray[float], exps: NDArray[float], L: int):
+    N = 0.0
+    for i, expi in enumerate(exps):
+        for j, expj in enumerate(exps):
+            tmp = coeffs[i] * coeffs[j] / (expi + expj) ** (L + 1.5)
+            tmp *= np.sqrt(expi * expj) ** (L + 1.5)
+            N += tmp
+    N = np.sqrt(exps ** (L + 1.5) / (np.pi**1.5 / 2**L * N))
+    # Or w/ array broadccasting
+    # N = coeffs[None, :] * coeffs[:, None] / (exps[None, :] + exps[:, None]) ** (L + 1.5)
+    # N = (N * np.sqrt((exps[None, :] * exps[:, None]) ** (L + 1.5))).sum()
+    # N = np.sqrt(exps ** (L + 1.5) / (np.pi**1.5 / 2**L * N))
+
+    mod_coeffs = N * coeffs
+    lmn_factors = get_lmn_factors(L)
+
+    return mod_coeffs, lmn_factors

pysisyphus/wavefunction/pop_analysis.py

@@ -0,0 +1,134 @@
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+import scipy as sp
+
+from pysisyphus.wavefunction.helpers import symmetric_orthogonalization
+from pysisyphus.wavefunction import Wavefunction
+
+
+@dataclass
+class PopAnalysis:
+    # atoms: List[str]
+    # coords3d: NDArray[float]
+    pop_a: NDArray[float]
+    pop_b: NDArray[float]
+    nuc_charges: NDArray[float]
+
+    @property
+    def charges(self):
+        return self.nuc_charges - self.pop_a - self.pop_b
+
+    @property
+    def tot_charge(self):
+        return self.charges.sum()
+
+    @property
+    def spin_pop(self):
+        return np.abs(self.pop_a - self.pop_b)
+
+    @property
+    def alpha_spin_pop(self):
+        spin_pop = self.pop_a - self.pop_b
+        beta_mask = spin_pop < 0.0
+        spin_pop[beta_mask] = 0.0
+        return spin_pop
+
+    @property
+    def beta_spin_pop(self):
+        spin_pop = self.pop_a - self.pop_b
+        alpha_mask = spin_pop > 0.0
+        spin_pop[alpha_mask] = 0.0
+        return np.abs(spin_pop)
+
+
+def mulliken_charges(
+    P: Tuple[NDArray[float]],
+    S: NDArray[float],
+    nuc_charges: NDArray[int],
+    ao_centers: List[int],
+) -> PopAnalysis:
+    def mulliken_atom_pops(P: NDArray[float], S: NDArray[float]) -> NDArray[float]:
+        ao_populations = np.einsum("ij,ji->i", P, S)
+        atom_populations = np.zeros(len(nuc_charges))
+        for i, center in enumerate(ao_centers):
+            atom_populations[center] += ao_populations[i]
+        return atom_populations
+
+    atom_populations_a = mulliken_atom_pops(P[0], S)
+    atom_populations_b = mulliken_atom_pops(P[1], S)
+
+    pop_ana = PopAnalysis(
+        pop_a=atom_populations_a,
+        pop_b=atom_populations_b,
+        nuc_charges=nuc_charges,
+    )
+    return pop_ana
+
+
+def mulliken_charges_from_wf(wf: Wavefunction) -> NDArray[float]:
+    return mulliken_charges(
+        P=wf.P,
+        S=wf.S,
+        nuc_charges=wf.nuc_charges,
+        ao_centers=wf.ao_centers,
+    )
+
+
+def make_iaos(
+    C_occ: NDArray[float],
+    S_org: NDArray[float],
+    S_minao: NDArray[float],
+    S_cross: NDArray[float],
+) -> NDArray[float]:
+    """Intrinsic atomic orbitals.
+
+    [1] https://doi.org/10.1021/ct400687b
+    """
+    P12 = sp.linalg.solve(S_org, S_cross)  # Projector on basis1, S1⁻¹ S12
+    P21 = sp.linalg.solve(S_minao, S_cross.T)  # Projector on basis2, S2⁻¹ S21
+
+    # Depolarized MOs in basis2
+    C2_depol = P12.dot(P21).dot(C_occ)
+    C2_depol = symmetric_orthogonalization(C2_depol, S_org)
+
+    O = C_occ.dot(C_occ.T).dot(S_org)
+    O_ = C2_depol.dot(C2_depol.T).dot(S_org)
+    iaos = (2 * O.dot(O_) - O_ - O).dot(P12) + P12
+    iaos = symmetric_orthogonalization(iaos, S_org)
+
+    return iaos
+
+
+def iao_charges_from_wf(wf: Wavefunction) -> PopAnalysis:
+    """IAO charges.
+
+    Extension to ES is described here:
+        https://chemistry.stackexchange.com/a/75913
+    """
+    S_org = wf.S
+    C_occ = wf.C_occ
+    minao_shells = wf.shells.from_basis("minao")
+    S_minao = getattr(minao_shells, "S_cart" if wf.is_cartesian else "S_sph")
+    S_cross = wf.S_with_shells(
+        minao_shells
+    )  # Overlap between original and MINAO  basis
+
+    def get_iao_P(C_occ: NDArray[float]):
+        iaos = make_iaos(C_occ, S_org, S_minao, S_cross)
+        C_iao = iaos.T @ S_org @ C_occ  # Projection of original MOs onto IAOs
+        P_iao = C_iao @ C_iao.T
+        return P_iao
+
+    # Always assume separate α C_occ and β C_occ matrices.
+    P_iao = np.array([get_iao_P(c_occ) for c_occ in C_occ])
+
+    minao_ao_centers = list(minao_shells.sph_ao_centers)
+    return mulliken_charges(
+        P=P_iao,
+        S=np.eye(len(minao_ao_centers)),
+        nuc_charges=wf.nuc_charges,
+        ao_centers=minao_ao_centers,
+    )