def init_guess_by_wolfsberg_helmholtz(mol): """Diagonal will be taken from core hamiltonian, the off diagonal elements are interpolated by wolfsberg helmholtz scheme. H_ji = k_ji (H_ii + H_ij) S_ij / 2, with k_ij =1.75 (Generalized Wolfsberg Helmholtz GWH). See here: http://www.q-chem.com/qchem-website/manual/qchem50_manual/sect-initialguess.html M. Wolfsberg and L. Helmholz, J. Chem. Phys. 20, 837 (1952). """ from pyscf.scf.hf import eig, get_hcore, get_ovlp, get_occ, make_rdm1, SCF import numpy H = numpy.diag(get_hcore(mol)) k = numpy.ones((len(H), len(H))) * 1.75 - \ numpy.diag(numpy.ones(H.shape)) * 0.75 S = get_ovlp(mol) H = k * numpy.add.outer(H, H) * S / 2 mo_energy, mo_coeff = eig(H, S) mo_occ = get_occ(SCF(mol), mo_energy, mo_coeff) return make_rdm1(mo_coeff, mo_occ)
def make_rdm1(mo_coeff_kpts, mo_occ_kpts, **kwargs): '''One particle density matrices for all k-points. Returns: dm_kpts : (nkpts, nao, nao) ndarray ''' nkpts = len(mo_occ_kpts) dm_kpts = [mol_hf.make_rdm1(mo_coeff_kpts[k], mo_occ_kpts[k]) for k in range(nkpts)] return lib.asarray(dm_kpts)
def init_guess_by_chkfile(cell, chkfile_name, project=True, kpt=None): '''Read the HF results from checkpoint file, then project it to the basis defined by ``cell`` Returns: Density matrix, (nao,nao) ndarray ''' chk_cell, scf_rec = chkfile.load_scf(chkfile_name) mo = scf_rec['mo_coeff'] mo_occ = scf_rec['mo_occ'] if kpt is None: kpt = np.zeros(3) if 'kpt' in scf_rec: chk_kpt = scf_rec['kpt'] elif 'kpts' in scf_rec: kpts = scf_rec['kpts'] # the closest kpt from KRHF results where = np.argmin(lib.norm(kpts - kpt, axis=1)) chk_kpt = kpts[where] if mo.ndim == 3: # KRHF: mo = mo[where] mo_occ = mo_occ[where] else: mo = mo[:, where] mo_occ = mo_occ[:, where] else: # from molecular code chk_kpt = np.zeros(3) def fproj(mo): if project: return addons.project_mo_nr2nr(chk_cell, mo, cell, chk_kpt - kpt) else: return mo if mo.ndim == 2: dm = make_rdm1(fproj(mo), mo_occ) else: # UHF dm = (make_rdm1(fproj(mo[0]), mo_occ[0]) + make_rdm1(fproj(mo[1]), mo_occ[1])) # Real DM for gamma point if kpt is None or np.allclose(kpt, 0): dm = dm.real return dm
def init_guess_by_huckel(self, mol=None): if mol is None: mol = self.mol logger.info( self, 'Initial guess from on-the-fly Huckel, doi:10.1021/acs.jctc.8b01089.' ) mo_energy, mo_coeff = hf.init_guess_by_huckel(mol) mo_occ = hf.get_occ(self, mo_energy, mo_coeff) dm = hf.make_rdm1(mo_coeff, mo_occ) return _from_rhf_init_dm(dm)
def make_rdm1(mo_coeff_kpts, mo_occ_kpts): '''One particle density matrices for all k-points. Returns: dm_kpts : (nkpts, nao, nao) ndarray ''' nkpts = len(mo_occ_kpts) dm_kpts = [hf.make_rdm1(mo_coeff_kpts[k], mo_occ_kpts[k]) for k in range(nkpts)] return lib.asarray(dm_kpts)
def init_guess_by_chkfile(cell, chkfile_name, project=True, kpt=None): '''Read the HF results from checkpoint file, then project it to the basis defined by ``cell`` Returns: Density matrix, (nao,nao) ndarray ''' chk_cell, scf_rec = chkfile.load_scf(chkfile_name) mo = scf_rec['mo_coeff'] mo_occ = scf_rec['mo_occ'] if kpt is None: kpt = np.zeros(3) if 'kpt' in scf_rec: chk_kpt = scf_rec['kpt'] elif 'kpts' in scf_rec: kpts = scf_rec['kpts'] # the closest kpt from KRHF results where = np.argmin(lib.norm(kpts-kpt, axis=1)) chk_kpt = kpts[where] if mo.ndim == 3: # KRHF: mo = mo[where] mo_occ = mo_occ[where] else: mo = mo[:,where] mo_occ = mo_occ[:,where] else: # from molecular code chk_kpt = np.zeros(3) def fproj(mo): if project: return addons.project_mo_nr2nr(chk_cell, mo, cell, chk_kpt-kpt) else: return mo if mo.ndim == 2: dm = make_rdm1(fproj(mo), mo_occ) else: # UHF dm =(make_rdm1(fproj(mo[0]), mo_occ[0]) + make_rdm1(fproj(mo[1]), mo_occ[1])) # Real DM for gamma point if kpt is None or np.allclose(kpt, 0): dm = dm.real return dm
def init_guess_by_chkfile(mol, chkfile_name, project=None): '''Read SCF chkfile and make the density matrix for GHF initial guess. Kwargs: project : None or bool Whether to project chkfile's orbitals to the new basis. Note when the geometry of the chkfile and the given molecule are very different, this projection can produce very poor initial guess. In PES scanning, it is recommended to swith off project. If project is set to None, the projection is only applied when the basis sets of the chkfile's molecule are different to the basis sets of the given molecule (regardless whether the geometry of the two molecules are different). Note the basis sets are considered to be different if the two molecules are derived from the same molecule with different ordering of atoms. ''' from pyscf.scf import addons chk_mol, scf_rec = chkfile.load_scf(chkfile_name) if project is None: project = not gto.same_basis_set(chk_mol, mol) # Check whether the two molecules are similar if abs(mol.inertia_moment() - chk_mol.inertia_moment()).sum() > 0.5: logger.warn( mol, "Large deviations found between the input " "molecule and the molecule from chkfile\n" "Initial guess density matrix may have large error.") if project: s = hf.get_ovlp(mol) def fproj(mo): if project: mo = addons.project_mo_nr2nr(chk_mol, mo, mol) norm = numpy.einsum('pi,pi->i', mo.conj(), s.dot(mo)) mo /= numpy.sqrt(norm) return mo nao = chk_mol.nao_nr() mo = scf_rec['mo_coeff'] mo_occ = scf_rec['mo_occ'] if getattr(mo[0], 'ndim', None) == 1: # RHF/GHF/DHF if nao * 2 == mo.shape[0]: # GHF or DHF if project: raise NotImplementedError('Project initial guess from ' 'different geometry') else: dm = hf.make_rdm1(mo, mo_occ) else: # RHF mo_coeff = fproj(mo) mo_occa = (mo_occ > 1e-8).astype(numpy.double) mo_occb = mo_occ - mo_occa dma, dmb = uhf.make_rdm1([mo_coeff] * 2, (mo_occa, mo_occb)) dm = scipy.linalg.block_diag(dma, dmb) else: #UHF if getattr(mo[0][0], 'ndim', None) == 2: # KUHF logger.warn( mol, 'k-point UHF results are found. Density matrix ' 'at Gamma point is used for the molecular SCF initial guess') mo = mo[0] dma, dmb = uhf.make_rdm1([fproj(mo[0]), fproj(mo[1])], mo_occ) dm = scipy.linalg.block_diag(dma, dmb) return dm
def project_init_guess (self, mo_coeff=None, cas_ao=None, prev_mol=None): if mo_coeff is None: mo_coeff = self.mo_coeff if prev_mol is not None: mo_coeff = addons.project_init_guess (self, mo_coeff, prev_mol) if cas_ao is None: cas_ao = self.cas_ao else: self.cas_ao, self.casrot_coeff, self.ncasrot = self.build_casrot (cas_ao) ncas = self.ncas ncore = self.ncore nocc = self.mol.nelectron // 2 dm0 = 2 * np.dot (mo_coeff[:,:nocc], mo_coeff[:,:nocc].conjugate ().T) self._scf.kernel (dm0) nocc = ncas + ncore ovlp_ao = self._scf.get_ovlp () fock_ao = self._scf.get_fock () ncasrot = self.ncasrot u_casrot = self.casrot_coeff[:,:ncasrot] assert (np.allclose (u_casrot[~cas_ao,:], 0)) projector = np.dot (u_casrot, u_casrot.conjugate ().T) # Project active orbitals mo_coeff[:,ncore:nocc] = reduce (np.dot, [projector, ovlp_ao, mo_coeff[:,ncore:nocc]]) assert (np.allclose (mo_coeff[~cas_ao,ncore:nocc], 0)) mo_coeff[:,ncore:nocc] = orth_orb (mo_coeff[:,ncore:nocc], ovlp_ao) # Remove active component of core orbitals mo_coeff[:,:ncore] -= reduce (np.dot, [mo_coeff[:,ncore:nocc], mo_coeff[:,ncore:nocc].conjugate ().T, ovlp_ao, mo_coeff[:,:ncore]]) mo_coeff[:,:ncore] = orth_orb (mo_coeff[:,:ncore], ovlp_ao) # Remove core-active component of virtual orbitals mo_coeff[:,nocc:] -= reduce (np.dot, [mo_coeff[:,:nocc], mo_coeff[:,:nocc].conjugate ().T, ovlp_ao, mo_coeff[:,nocc:]]) mo_coeff[:,nocc:] = orth_orb (mo_coeff[:,nocc:], ovlp_ao) assert (np.allclose (mo_coeff[~cas_ao,ncore:nocc], 0)) assert (is_basis_orthonormal (mo_coeff, ovlp_ao)) # sort active orbitals by energy mo_energy = np.einsum ('ip,ij,jp->p', mo_coeff.conjugate (), fock_ao, mo_coeff.T) amo_energy = mo_energy[ncore:nocc] amo_coeff = mo_coeff[:,ncore:nocc] idx = amo_energy.argsort () amo_energy = amo_energy[idx] amo_coeff = amo_coeff[:,idx] mo_energy[ncore:nocc] = amo_energy mo_coeff[:,ncore:nocc] = amo_coeff # fc-scf to get the correct core nelecb = self.mol.nelectron // 2 neleca = nelecb + (self.mol.nelectron % 2) mo_occ = np.zeros (mo_coeff.shape[1]) mo_occ[:neleca] += 1 mo_occ[:nelecb] += 1 casdm1 = np.diag (mo_occ[ncore:nocc]) self._scf.build_frozen_from_mo (mo_coeff, ncore, ncas) self._scf.diis = None dm0 = hf.make_rdm1 (mo_coeff, mo_occ) self._scf.kernel (dm0) amo_ovlp = reduce (np.dot, [mo_coeff[:,ncore:nocc].conjugate ().T, ovlp_ao, self._scf.mo_coeff[:,ncore:nocc]]) amo_ovlp = np.dot (amo_ovlp, amo_ovlp.conjugate ().T) err = np.trace (amo_ovlp) - ncas assert (abs (err) < 1e-10), "{0}".format (amo_ovlp) assert (np.allclose (self._scf.mo_coeff[~cas_ao,ncore:nocc], 0)) return self._scf.mo_coeff