#!/usr/bin/env python3 """UKS PBE0/def2-QZVP from XYZ: SCF grid 3, store rho/grid on level 1.""" from __future__ import annotations import argparse import pickle import re from pathlib import Path import numpy as np from pyscf import df, dft, gto from pyscf.data.nist import BOHR try: import dftd3.pyscf as d3 except ImportError as e: raise SystemExit("need dftd3 (pip install dftd3): " + str(e)) from e BASIS = "def2-qzvp" AUXBASIS = "def2-universal-jkfit" XC = "PBE0" SCF_GRID = 3 STORE_GRID = 1 _CHARGE_RE = re.compile(r"(?:^|[,\s])charge\s*=\s*([+-]?\d+)", re.I) _MULT_RE = re.compile(r"(?:^|[,\s])multiplicity\s*=\s*(\d+)", re.I) def parse_xyz(path): lines = Path(path).read_text().splitlines() if len(lines) < 3: raise ValueError(f"bad xyz: {path}") comment = lines[1] charge = spin = None m = _CHARGE_RE.search(comment) if m: charge = int(m.group(1)) m = _MULT_RE.search(comment) if m: spin = int(m.group(1)) - 1 atoms = [] for line in lines[2:]: p = line.split() if len(p) >= 4: atoms.append(f"{p[0]} {p[1]} {p[2]} {p[3]}") if not atoms: raise ValueError(f"no atoms in {path}") return "\n".join(atoms), charge, spin def as_uks_dm(dm): dm = np.asarray(dm, dtype=np.float64) if dm.ndim == 2: return np.stack([0.5 * dm, 0.5 * dm], axis=0) if dm.ndim == 3 and dm.shape[0] == 2: return dm raise ValueError(f"dm shape {dm.shape}") def b3lyp_xc_semilocal(rho, weights): """Semilocal B3LYP XC on a given density (no HF piece).""" rho = np.asarray(rho) w = np.asarray(weights, dtype=np.float64) rho_gga = rho[:, :4, :].astype(np.float64, copy=False) spin = 1 if rho_gga.shape[0] == 2 else 0 den = rho_gga[0, 0] + rho_gga[1, 0] if spin == 1 else rho_gga[0, 0] ni = dft.numint.NumInt() ex, _, _, _ = ni.eval_xc(".08*SLATER + .72*B88,", rho_gga, spin=spin) ec, _, _, _ = ni.eval_xc(",0.81*LYP + .19*VWN3", rho_gga, spin=spin) e_x = float(np.dot(ex * den, w)) e_c = float(np.dot(ec * den, w)) return e_x, e_c, e_x + e_c def density_on_grid(mol, dm, level): grids = dft.gen_grid.Grids(mol) grids.level = int(level) grids.build() coords = np.asarray(grids.coords, dtype=np.float64) weights = np.asarray(grids.weights, dtype=np.float64) ao = dft.numint.eval_ao(mol, coords, deriv=2) rho = np.stack( [ dft.numint.eval_rho(mol, ao, dm[0], xctype="MGGA"), dft.numint.eval_rho(mol, ao, dm[1], xctype="MGGA"), ], axis=0, ) return coords, weights, rho def featurize(atom, charge, spin, basis=BASIS, auxbasis=AUXBASIS, xc=XC, conv_tol=1e-8): mol = gto.Mole() mol.atom = atom mol.basis = basis mol.charge = int(charge) mol.spin = int(spin) mol.verbose = 0 mol.build() mf = dft.UKS(mol) mf.xc = xc mf.grids.level = SCF_GRID mf.conv_tol = conv_tol mf = mf.density_fit(auxbasis=auxbasis) e_tot = mf.kernel() converged = bool(mf.converged) dm = as_uks_dm(mf.make_rdm1()) vj, vk = mf.get_jk(mol, dm) hcore = mf.get_hcore() dma = dm[0] + dm[1] Enuc = float(mol.energy_nuc()) E1e = float(np.einsum("ij,ji->", dma, hcore)) EH = float(0.5 * np.einsum("ij,ji->", dma, vj[0] + vj[1])) E_unxc = Enuc + E1e + EH # positive HF-x scalar: hybrid baselines use E -= a * hf_x hf_x = float(0.5 * (np.einsum("ij,ji->", dm[0], vk[0]) + np.einsum("ij,ji->", dm[1], vk[1]))) S = mol.intor_symmetric("int1e_ovlp") Fock = np.asarray(mf.get_fock(h1e=hcore, s1e=S, dm=dm), dtype=np.float64) K = np.asarray(vk, dtype=np.float64) grid_coords, weights, rho = density_on_grid(mol, dm, STORE_GRID) _, _, E_xc_b3lyp = b3lyp_xc_semilocal(rho, weights) d3bj_b3lyp = float(d3.DFTD3Dispersion(mol=mol, xc="b3lyp", version="d3bj").kernel()[0]) symbols = [mol.atom_symbol(i) for i in range(mol.natm)] numbers = np.array([mol.atom_charge(i) for i in range(mol.natm)], dtype=np.int32) atom_coords_bohr = np.asarray(mol.atom_coords(), dtype=np.float64) coords_ang = atom_coords_bohr * BOHR return { "atoms": symbols, "symbols": symbols, "numbers": numbers, "atom_coords": atom_coords_bohr, "coords": coords_ang, "charge": int(charge), "spin": int(spin), "multiplicity": int(spin) + 1, "dm": dm.astype(np.float32), "Fock": Fock.astype(np.float32), "K": K.astype(np.float32), "Enuc": Enuc, "E1e": E1e, "EH": EH, "E_unxc": E_unxc, "hf_x": hf_x, "grid_coords": grid_coords.astype(np.float32), "weights": weights.astype(np.float32), "rho": rho.astype(np.float32), "E_xc_b3lyp": float(E_xc_b3lyp), "d3bj_b3lyp": d3bj_b3lyp, "natoms": int(mol.natm), "ngrid": int(weights.shape[0]), "nao": int(mol.nao_nr()), "converged": converged, "scf_energy": float(e_tot), "scf_grid_level": SCF_GRID, "store_grid_level": STORE_GRID, "xyz": mol.tostring(), } def main(): ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--xyz", type=Path, required=True) ap.add_argument("--out", type=Path, required=True) ap.add_argument("--charge", type=int, default=None) ap.add_argument("--spin", type=int, default=None, help="2S = Nα-Nβ") ap.add_argument("--basis", default=BASIS) ap.add_argument("--auxbasis", default=AUXBASIS) ap.add_argument("--xc", default=XC) args = ap.parse_args() atom, ch_xyz, spin_xyz = parse_xyz(args.xyz) charge = args.charge if args.charge is not None else (ch_xyz if ch_xyz is not None else 0) spin = args.spin if args.spin is not None else (spin_xyz if spin_xyz is not None else 0) data = featurize(atom, charge, spin, basis=args.basis, auxbasis=args.auxbasis, xc=args.xc) args.out.parent.mkdir(parents=True, exist_ok=True) with open(args.out, "wb") as f: pickle.dump(data, f, protocol=5) print( f"{args.out}: converged={data['converged']} " f"scf_grid={data['scf_grid_level']} store_grid={data['store_grid_level']} " f"ngrid={data['ngrid']} Enuc={data['Enuc']:.6f} E1e={data['E1e']:.6f} " f"EH={data['EH']:.6f} hf_x={data['hf_x']:.6f}" ) if __name__ == "__main__": main()