def test_nr_rhf_cart(self): pmol = mol.copy() pmol.cart = True mf = scf.RHF(pmol).run() self.assertAlmostEqual(mf.e_tot, -76.027107008870573, 9)
def setUpClass(cls): mol = gto.M(atom='O 0 0 0; H 0 0 1; H 0 1 0', basis='cc-pvdz', verbose=0) cls.mf = scf.RHF(mol) cls.mf.run(conv_tol=1e-12)
from pyscf import cc from pyscf import ao2mo def finger(a): return numpy.dot(a.ravel(), numpy.cos(numpy.arange(a.size))) mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]] mol.basis = 'cc-pvdz' mol.verbose = 0 mol.spin = 0 mol.build() mf = scf.RHF(mol).run() mf1 = copy.copy(mf) no = mol.nelectron // 2 n = mol.nao_nr() nv = n - no mf1.mo_occ = numpy.zeros(mol.nao_nr()) mf1.mo_occ[:no] = 2 numpy.random.seed(12) mf1.mo_coeff = numpy.random.random((n, n)) dm = mf1.make_rdm1(mf1.mo_coeff, mf1.mo_occ) fockao = mf1.get_hcore() + mf1.get_veff(mol, dm) mf1.mo_energy = numpy.einsum('pi,pq,qi->i', mf1.mo_coeff, fockao, mf1.mo_coeff) idx = numpy.hstack( [mf1.mo_energy[:no].argsort(), no + mf1.mo_energy[no:].argsort()]) mf1.mo_coeff = mf1.mo_coeff[:, idx]
def test_nr_rhf_no_direct(self): rhf = scf.RHF(mol) rhf.conv_tol = 1e-11 rhf.max_memory = 0 rhf.direct_scf = False self.assertAlmostEqual(rhf.scf(), -76.02676567311957, 9)
from pyscf import mcscf from pyscf.mcscf import addons mol = gto.Mole() mol.atom = [ ['O', (0., 0., 0.)], ['H', (0., -0.757, 0.587)], ['H', (0., 0.757, 0.587)], ] mol.basis = { 'H': 'cc-pvdz', 'O': 'cc-pvdz', } mol.build() m = scf.RHF(mol) ehf = m.scf() mc = approx_hessian(mcscf.CASSCF(m, 6, 4)) mc.verbose = 4 mo = addons.sort_mo(mc, m.mo_coeff, (3, 4, 6, 7, 8, 9), 1) emc = mc.kernel(mo)[0] print(ehf, emc, emc - ehf) #-76.0267656731 -76.0873922924 -0.0606266193028 print(emc - -76.0873923174, emc - -76.0926176464) mc = approx_hessian(mcscf.CASSCF(m, 6, (3, 1))) mc.verbose = 4 emc = mc.mc2step(mo)[0] print(emc - -75.7155632535814) mf = scf.density_fit(m)
Optimize molecular geometry within the environment of QM/MM charges. ''' import numpy from pyscf import gto, scf, cc, qmmm from pyscf.geomopt import berny_solver mol = gto.M(atom=''' C 1.1879 -0.3829 0.0000 C 0.0000 0.5526 0.0000 O -1.1867 -0.2472 0.0000 H -1.9237 0.3850 0.0000 H 2.0985 0.2306 0.0000 H 1.1184 -1.0093 0.8869 H 1.1184 -1.0093 -0.8869 H -0.0227 1.1812 0.8852 H -0.0227 1.1812 -0.8852 ''', basis='3-21g') numpy.random.seed(1) coords = numpy.random.random((5, 3)) * 10 charges = (numpy.arange(5) + 1.) * -.001 mf = qmmm.mm_charge(scf.RHF(mol), coords, charges) #mf.verbose=4 #mf.kernel() mol1 = berny_solver.optimize(mf) mycc = cc.CCSD(mf) mol1 = berny_solver.optimize(mycc)
def test_nr_df_rhf(self): rhf = scf.density_fit(scf.RHF(mol)) rhf.conv_tol = 1e-11 self.assertAlmostEqual(rhf.scf(), -76.025936299701982, 9)
import matplotlib.pyplot as plt mol_h2 = gto.Mole() mol_h2.basis = 'sto-3g' nl = 50 bond_length = np.linspace(0.2, 4, nl) rhf_tot_energies = np.zeros(nl) uhf_tot_energies = np.zeros(nl) for i in range(0, nl): mol_h2.atom = [['H', (0, 0, 0)], ['H', (0, 0, bond_length[i])]] mol_h2.build() rhf_h2 = scf.RHF(mol_h2).run() rhf_tot_energies[i] = rhf_h2.energy_tot() uhf_h2 = scf.UHF(mol=mol_h2).newton() uhf_h2.max_cycle = 500 ig = uhf_h2.init_guess_by_minao(mol=mol_h2, breaksym=True) #print(ig) ig = ig + 0.1 * np.random.randn(*np.shape(ig)) uhf_h2.kernel(dm0=ig) uhf_tot_energies[i] = uhf_h2.energy_tot() plt.plot(bond_length, rhf_tot_energies)
def fromOptions(self, inputParams): import numpy as np from pyscf import gto, scf, dft, tddft mol = gto.mole.Mole() mol.atom = inputParams['geometry'] mol.basis = inputParams['basis'] scf_wfn = scf.RHF(mol) # needs to be changed for open-shells scf_wfn.conv_tol = 1e-8 scf_wfn.kernel() # runs RHF calculations scf_e = scf_wfn.e_tot E_nucl = mol.energy_nuc() # Get MO coefficients from SCF wavefunction # ==> ERIs <== # Create instance of MintsHelper class: nbf = mol.nao # number of basis functions nso = 2 * nbf # number of spin orbitals # Assuming RHF for now, easy to generalize later nalpha = (scf_wfn.mo_occ == 2).sum() nbeta = (scf_wfn.mo_occ == 2).sum() nocc = nalpha + nbeta # number of occupied orbitals nvirt = 2 * nbf - nocc # number of virtual orbitals list_occ_alpha = scf_wfn.mo_occ list_occ_beta = scf_wfn.mo_occ # Get orbital energies eps_a = scf_wfn.mo_energy eps_b = scf_wfn.mo_energy eps = np.append(eps_a, eps_b) # Get orbital coefficients: Ca = scf_wfn.mo_coeff Cb = scf_wfn.mo_coeff C = np.block([[Ca, np.zeros_like(Cb)], [np.zeros_like(Ca), Cb]]) # Get the two electron integrals using MintsHelper Ints = mol.intor('int2e_sph') def spin_block_tei(I): """ Function that spin blocks two-electron integrals Using np.kron, we project I into the space of the 2x2 identity, tranpose the result and project into the space of the 2x2 identity again. This doubles the size of each axis. The result is our two electron integral tensor in the spin orbital form. """ identity = np.eye(2) I = np.kron(identity, I) return np.kron(identity, I.T) # Spin-block the two electron integral array I_spinblock = spin_block_tei(Ints) # Converts chemist's notation to physicist's notation, and antisymmetrize # (pq | rs) ---> <pr | qs> # Physicist's notation tmp = I_spinblock.transpose(0, 2, 1, 3) # Antisymmetrize: # <pr||qs> = <pr | qs> - <pr | sq> gmo = tmp - tmp.transpose(0, 1, 3, 2) gmo = np.einsum('pqrs, sS -> pqrS', gmo, C) gmo = np.einsum('pqrS, rR -> pqRS', gmo, C) gmo = np.einsum('pqRS, qQ -> pQRS', gmo, C) gmo = np.einsum('pQRS, pP -> PQRS', gmo, C) # -------- 0-body term: Hamiltonian_0body = E_nucl # -------- 1-body term: # Ca* # Build core Hamiltonian T = mol.intor_symmetric('int1e_kin') V = mol.intor_symmetric('int1e_nuc') H_core_ao = T + V # -- check which one more efficient (matmul vs einsum) # H_core_mo = np.matmul(Ca.T,np.matmul(H_core_ao,Ca))) # H_core_mo = np.einsum('ij, jk, kl -> il', Ca.T, H_core_ao, Ca) H_core_mo_alpha = H_core_mo H_core_mo_beta = H_core_mo # ---- this version breaks is we permuted SCF eigvecs # Hamiltonian_1body = np.block([ # [ H_core_mo_alpha , np.zeros_like(H_core_mo_alpha)], # [np.zeros_like(H_core_mo_beta) , H_core_mo_beta ]]) # # --- th is version is safer than above (H_1b is permutted correctly if eigvecs are permutted) Hamiltonian_1body_ao = np.block([[H_core_ao, np.zeros_like(H_core_ao)], [np.zeros_like(H_core_ao), H_core_ao]]) Hamiltonian_1body = np.einsum('ij, jk, kl -> il', C.T, Hamiltonian_1body_ao, C) Hamiltonian_2body = gmo if 'frozen-spin-orbitals' in inputParams and 'active-spin-orbitals' in inputParams: MSO_frozen_list = inputParams['frozen-spin-orbitals'] MSO_active_list = inputParams['active-spin-orbitals'] n_frozen = len(MSO_frozen_list) n_active = len(MSO_active_list) else: MSO_frozen_list = [] MSO_active_list = range(Hamiltonian_1body.shape[0]) n_frozen = 0 n_active = len(MSO_active_list) # ----- 0-body frozen-core: Hamiltonian_fc_0body = E_nucl for a in range(n_frozen): ia = MSO_frozen_list[a] Hamiltonian_fc_0body += Hamiltonian_1body[ia, ia] for b in range(a): ib = MSO_frozen_list[b] Hamiltonian_fc_0body += gmo[ia, ib, ia, ib] f_str = str(Hamiltonian_fc_0body) pos_or_neg = lambda x: ' + ' if x > 0. else ' - ' # --- 1-body frozen-core: Hamiltonian_fc_1body = np.zeros((n_active, n_active)) Hamiltonian_fc_1body_tmp = np.zeros((n_active, n_active)) for p in range(n_active): ip = MSO_active_list[p] for q in range(n_active): iq = MSO_active_list[q] Hamiltonian_fc_1body[p, q] = Hamiltonian_1body[ip, iq] #Hamiltonian_fc_1body_tmp[p,q] = Hamiltonian_1body[ip,iq] for a in range(n_frozen): ia = MSO_frozen_list[a] Hamiltonian_fc_1body[p, q] += gmo[ia, ip, ia, iq] if abs(Hamiltonian_fc_1body[p, q]) > 1e-12: f_str += pos_or_neg(Hamiltonian_fc_1body[p, q]) + str( abs(Hamiltonian_fc_1body[p, q])) + ' ' + str( p) + '^ ' + str(q) # ------- 2-body frozen-core: Hamiltonian_fc_2body = np.zeros( (n_active, n_active, n_active, n_active)) for p in range(n_active): ip = MSO_active_list[p] for q in range(n_active): iq = MSO_active_list[q] for r in range(n_active): ir = MSO_active_list[r] for ss in range(n_active): iss = MSO_active_list[ss] #Hamiltonian_fc_2body[p,q,r,ss]= 0.25* gmo[ip,iq,ir,iss] Hamiltonian_fc_2body[p, q, r, ss] = gmo[ip, iq, ir, iss] #Hamiltonian_fc_2body[p,q,r,ss]= 0.25* gmo[ip,iq,iss,ir] Hamiltonian_fc_2body_tmp = 0.25 * Hamiltonian_fc_2body.transpose( 0, 1, 3, 2) for p in range(n_active): ip = MSO_active_list[p] for q in range(n_active): iq = MSO_active_list[q] for r in range(n_active): ir = MSO_active_list[r] for ss in range(n_active): if abs(Hamiltonian_fc_2body_tmp[p, q, r, ss]) > 1e-12: f_str += pos_or_neg( Hamiltonian_fc_2body_tmp[p, q, r, ss]) + str( abs(Hamiltonian_fc_2body_tmp[p, q, r, ss]) ) + ' ' + str(p) + '^ ' + str(q) + '^ ' + str( r) + ' ' + str(ss) self.observable = xacc.getObservable('fermion', f_str) self.asPauli = xacc.transformToPauli('jw', self.observable)
def _irrep_argsort(orbsym): return numpy.hstack([numpy.where(orbsym == i)[0] for i in range(8)]) if __name__ == '__main__': from pyscf import gto from pyscf import scf from pyscf import cc mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -.957, .587)], [1, (0.2, .757, .487)]] mol.basis = 'ccpvdz' mol.build() rhf = scf.RHF(mol) rhf.conv_tol = 1e-14 rhf.scf() mcc = cc.CCSD(rhf) mcc.conv_tol = 1e-14 mcc.ccsd() e3a = kernel(mcc, mcc.ao2mo()) print(e3a - -0.0033300722704016289) mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -.757, .587)], [1, (0., .757, .587)]] mol.symmetry = True mol.basis = 'ccpvdz' mol.build()
def solve(CONST, OEI, FOCK, TEI, Norb, Nel, Nimp, DMguessRHF, energytype='LAMBDA', chempot_imp=0.0, printoutput=True): assert ((energytype == 'LAMBDA') or (energytype == 'LAMBDA_AMP') or (energytype == 'LAMBDA_ZERO') or (energytype == 'CASCI')) # Killing output if necessary if (printoutput == False): sys.stdout.flush() old_stdout = sys.stdout.fileno() new_stdout = os.dup(old_stdout) devnull = os.open('/dev/null', os.O_WRONLY) os.dup2(devnull, old_stdout) os.close(devnull) # Augment the FOCK operator with the chemical potential FOCKcopy = FOCK.copy() if (chempot_imp != 0.0): for orb in range(Nimp): FOCKcopy[orb, orb] -= chempot_imp # Get the RHF solution mol = gto.Mole() mol.build(verbose=0) mol.atom.append(('C', (0, 0, 0))) mol.nelectron = Nel mol.incore_anyway = True mf = scf.RHF(mol) mf.get_hcore = lambda *args: FOCKcopy mf.get_ovlp = lambda *args: np.eye(Norb) mf._eri = ao2mo.restore(8, TEI, Norb) mf.scf(DMguessRHF) DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T) if (mf.converged == False): mf = mf.newton() DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T) # Check the RHF solution assert (Nel % 2 == 0) numPairs = Nel / 2 FOCKloc = FOCKcopy + np.einsum( 'ijkl,ij->kl', TEI, DMloc) - 0.5 * np.einsum('ijkl,ik->jl', TEI, DMloc) eigvals, eigvecs = np.linalg.eigh(FOCKloc) idx = eigvals.argsort() eigvals = eigvals[idx] eigvecs = eigvecs[:, idx] # print "psi4cc::solve : RHF h**o-lumo gap =", eigvals[numPairs] - eigvals[numPairs-1] DMloc2 = 2 * np.dot(eigvecs[:, :numPairs], eigvecs[:, :numPairs].T) # print "Two-norm difference of 1-RDM(RHF) and 1-RDM(FOCK(RHF)) =", np.linalg.norm(DMloc - DMloc2) # Get the CC solution from pyscf ccsolver = ccsd.CCSD(mf) ccsolver.verbose = 1 ECORR, t1, t2 = ccsolver.ccsd() ERHF = mf.e_tot ECCSD = ERHF + ECORR # Compute the impurity energy if (energytype == 'CASCI'): # The 2-RDM is not required # Active space energy is computed with the Fock operator of the core (not rescaled) # print "ECCSD =", ECCSD ccsolver.solve_lambda() pyscfRDM1 = ccsolver.make_rdm1() # MO space pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize pyscfRDM1 = np.dot(mf.mo_coeff, np.dot(pyscfRDM1, mf.mo_coeff.T)) # From MO to localized space ImpurityEnergy = ECCSD if (chempot_imp != 0.0): # [FOCK - FOCKcopy]_{ij} = chempot_imp * delta(i,j) * delta(i \in imp) ImpurityEnergy += np.einsum('ij,ij->', FOCK - FOCKcopy, pyscfRDM1) else: # Compute the DMET impurity energy based on the lambda equations if (energytype == 'LAMBDA'): ccsolver.solve_lambda() pyscfRDM1 = ccsolver.make_rdm1() # MO space pyscfRDM2 = ccsolver.make_rdm2() # MO space if (energytype == 'LAMBDA_AMP'): # Overwrite lambda tensors with t-amplitudes pyscfRDM1 = ccsolver.make_rdm1(t1, t2, t1, t2) # MO space pyscfRDM2 = ccsolver.make_rdm2(t1, t2, t1, t2) # MO space if (energytype == 'LAMBDA_ZERO'): # Overwrite lambda tensors with 0.0 fake_l1 = np.zeros(t1.shape, dtype=float) fake_l2 = np.zeros(t2.shape, dtype=float) pyscfRDM1 = ccsolver.make_rdm1(t1, t2, fake_l1, fake_l2) # MO space pyscfRDM2 = ccsolver.make_rdm2(t1, t2, fake_l1, fake_l2) # MO space pyscfRDM1 = 0.5 * (pyscfRDM1 + pyscfRDM1.T) # Symmetrize # Print a few to things to double check ''' print "Do we understand how the 1-RDM is stored?", np.linalg.norm( np.einsum('ii->', pyscfRDM1) - Nel ) print "Do we understand how the 2-RDM is stored?", np.linalg.norm( np.einsum('ijkk->ij', pyscfRDM2) / (Nel - 1.0) - pyscfRDM1 ) ''' # Change the pyscfRDM1/2 from MO space to localized space pyscfRDM1 = np.dot(mf.mo_coeff, np.dot(pyscfRDM1, mf.mo_coeff.T)) pyscfRDM2 = np.einsum('ai,ijkl->ajkl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('bj,ajkl->abkl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('ck,abkl->abcl', mf.mo_coeff, pyscfRDM2) pyscfRDM2 = np.einsum('dl,abcl->abcd', mf.mo_coeff, pyscfRDM2) ECCSDbis = CONST + np.einsum( 'ij,ij->', FOCKcopy, pyscfRDM1) + 0.5 * np.einsum('ijkl,ijkl->', TEI, pyscfRDM2) # print "ECCSD1 =", ECCSD # print "ECCSD2 =", ECCSDbis # To calculate the impurity energy, rescale the JK matrix with a factor 0.5 to avoid double counting: 0.5 * ( OEI + FOCK ) = OEI + 0.5 * JK ImpurityEnergy = CONST \ + 0.25 * np.einsum('ij,ij->', pyscfRDM1[:Nimp,:], FOCK[:Nimp,:] + OEI[:Nimp,:]) \ + 0.25 * np.einsum('ij,ij->', pyscfRDM1[:,:Nimp], FOCK[:,:Nimp] + OEI[:,:Nimp]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:Nimp,:,:,:], TEI[:Nimp,:,:,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:Nimp,:,:], TEI[:,:Nimp,:,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:Nimp,:], TEI[:,:,:Nimp,:]) \ + 0.125 * np.einsum('ijkl,ijkl->', pyscfRDM2[:,:,:,:Nimp], TEI[:,:,:,:Nimp]) # Reviving output if necessary if (printoutput == False): sys.stdout.flush() os.dup2(new_stdout, old_stdout) os.close(new_stdout) return (ImpurityEnergy, pyscfRDM1)
def kernel(gw, mo_energy, mo_coeff, Lpq=None, orbs=None, nw=None, vhf_df=False, verbose=logger.NOTE): ''' GW-corrected quasiparticle orbital energies Returns: A list : converged, mo_energy, mo_coeff ''' mf = gw._scf # only support frozen core assert (isinstance(gw.frozen, int)) assert (gw.frozen < gw.nocc) if Lpq is None: Lpq = gw.ao2mo(mo_coeff) if orbs is None: orbs = range(gw.nmo) else: orbs = [x - gw.frozen for x in orbs] if orbs[0] < 0: logger.warn(gw, 'GW orbs must be larger than frozen core!') raise RuntimeError # v_xc v_mf = mf.get_veff() - mf.get_j() v_mf = reduce(numpy.dot, (mo_coeff.T, v_mf, mo_coeff)) nocc = gw.nocc nmo = gw.nmo nvir = nmo - nocc # v_hf from DFT/HF density if vhf_df and gw.frozen == 0: # density fitting for vk vk = -einsum('Lni,Lim->nm', Lpq[:, :, :nocc], Lpq[:, :nocc, :]) else: # exact vk without density fitting dm = mf.make_rdm1() rhf = scf.RHF(gw.mol) vk = rhf.get_veff(gw.mol, dm) - rhf.get_j(gw.mol, dm) vk = reduce(numpy.dot, (mo_coeff.T, vk, mo_coeff)) # Grids for integration on imaginary axis freqs, wts = _get_scaled_legendre_roots(nw) # Compute self-energy on imaginary axis i*[0,iw_cutoff] sigmaI, omega = get_sigma_diag(gw, orbs, Lpq, freqs, wts, iw_cutoff=5.) # Analytic continuation if gw.ac == 'twopole': coeff = AC_twopole_diag(sigmaI, omega, orbs, nocc) elif gw.ac == 'pade': coeff, omega_fit = AC_pade_thiele_diag(sigmaI, omega) conv = True mf_mo_energy = mo_energy.copy() ef = (mo_energy[nocc - 1] + mo_energy[nocc]) / 2. mo_energy = np.zeros_like(gw._scf.mo_energy) for p in orbs: if gw.linearized: # linearized G0W0 de = 1e-6 ep = mf_mo_energy[p] #TODO: analytic sigma derivative if gw.ac == 'twopole': sigmaR = two_pole(ep - ef, coeff[:, p - orbs[0]]).real dsigma = two_pole(ep - ef + de, coeff[:, p - orbs[0]]).real - sigmaR.real elif gw.ac == 'pade': sigmaR = pade_thiele(ep - ef, omega_fit[p - orbs[0]], coeff[:, p - orbs[0]]).real dsigma = pade_thiele(ep - ef + de, omega_fit[p - orbs[0]], coeff[:, p - orbs[0]]).real - sigmaR.real zn = 1.0 / (1.0 - dsigma / de) e = ep + zn * (sigmaR.real + vk[p, p] - v_mf[p, p]) mo_energy[p + gw.frozen] = e else: # self-consistently solve QP equation def quasiparticle(omega): if gw.ac == 'twopole': sigmaR = two_pole(omega - ef, coeff[:, p - orbs[0]]).real elif gw.ac == 'pade': sigmaR = pade_thiele(omega - ef, omega_fit[p - orbs[0]], coeff[:, p - orbs[0]]).real return omega - mf_mo_energy[p] - (sigmaR.real + vk[p, p] - v_mf[p, p]) try: e = newton(quasiparticle, mf_mo_energy[p], tol=1e-6, maxiter=100) mo_energy[p + gw.frozen] = e except RuntimeError: conv = False if gw.verbose >= logger.DEBUG: numpy.set_printoptions(threshold=nmo) logger.debug(gw, ' GW mo_energy =\n%s', mo_energy) numpy.set_printoptions(threshold=1000) return conv, mo_energy, mo_coeff
def test_update_from_chk(self): mf1 = scf.RHF(mol).update(mf.chkfile) self.assertAlmostEqual(mf1.e_tot, mf.e_tot, 12)
def test_apply(self): from pyscf import mp self.assertTrue(isinstance(mf.apply(mp.MP2), mp.mp2.RMP2)) mf1 = scf.RHF(mol) self.assertTrue(isinstance(mf1.apply('MP2'), mp.mp2.RMP2))
return gccsd_rdm._make_rdm2(mycc, d1, d2, True, True) if __name__ == '__main__': from functools import reduce from pyscf import gto from pyscf import scf from pyscf import ao2mo from pyscf import cc mol = gto.Mole() mol.atom = [[8, (0., 0., 0.)], [1, (0., -.957, .587)], [1, (0.2, .757, .487)]] mol.basis = '631g' mol.build() mf0 = mf = scf.RHF(mol).run(conv_tol=1.) mf = scf.addons.convert_to_ghf(mf) from pyscf.cc import ccsd_t_lambda_slow as ccsd_t_lambda from pyscf.cc import ccsd_t_rdm_slow as ccsd_t_rdm mycc0 = cc.CCSD(mf0) eris0 = mycc0.ao2mo() mycc0.kernel(eris=eris0) t1 = mycc0.t1 t2 = mycc0.t2 imds = ccsd_t_lambda.make_intermediates(mycc0, t1, t2, eris0) l1, l2 = ccsd_t_lambda.update_lambda(mycc0, t1, t2, t1, t2, eris0, imds) dm1ref = ccsd_t_rdm.make_rdm1(mycc0, t1, t2, l1, l2, eris0) dm2ref = ccsd_t_rdm.make_rdm2(mycc0, t1, t2, l1, l2, eris0) mycc = cc.GCCSD(mf)
''' This example shows how to use pseudo spectral integrals in SCF calculation. ''' from pyscf import gto from pyscf import scf from pyscf import sgx mol = gto.M( atom='''O 0. 0. 0. H 0. -0.757 0.587 H 0. 0.757 0.587 ''', basis='ccpvdz', ) # Direct K matrix for comparison mf = scf.RHF(mol) mf.kernel() # Using SGX for J-matrix and K-matrix mf = sgx.sgx_fit(scf.RHF(mol), pjs=False) mf.kernel() # Using RI for Coulomb matrix while K-matrix is constructed with COS-X method mf.with_df.dfj = True mf.kernel() # Turn on P-junction screening to accelerate large calculations # (uses algorithm similar to COSX) mf.with_df.pjs = True mf.kernel()
def setUpClass(cls): mol = gto.M(atom='O 0 0 0; H 0 0 1; H 0 1 0', basis='cc-pvdz', verbose=0) cls.mf = scf.RHF(mol) cls.mf = cls.mf.density_fit(auxbasis='aug-cc-pvqz-ri') cls.mf.run(conv_tol=1e-12)
del(WITH_T2) if __name__ == '__main__': from pyscf import scf from pyscf import gto mol = gto.Mole() mol.verbose = 0 mol.atom = [ [8 , (0. , 0. , 0.)], [1 , (0. , -0.757 , 0.587)], [1 , (0. , 0.757 , 0.587)]] mol.basis = 'cc-pvdz' mol.build() mf = scf.RHF(mol).run() pt = DFMP2(mf) emp2, t2 = pt.kernel() print(emp2 - -0.204004830285) pt.with_df = df.DF(mol) pt.with_df.auxbasis = 'weigend' emp2, t2 = pt.kernel() print(emp2 - -0.204254500453) mf = scf.density_fit(scf.RHF(mol), 'weigend') mf.kernel() pt = DFMP2(mf) emp2, t2 = pt.kernel() print(emp2 - -0.203986171133)
def test_nr_rhf(self): rhf = scf.RHF(mol) rhf.conv_tol = 1e-11 self.assertAlmostEqual(rhf.scf(), -76.026765673119627, 9)
from pyscf import scf from pyscf import mcscf from pyscf import fci b = 1.4 mol = gto.Mole() mol.build(verbose=0, atom=[ ['N', (0.000000, 0.000000, -b / 2)], ['N', (0.000000, 0.000000, b / 2)], ], basis={ 'N': 'ccpvdz', }, symmetry=1) mfr = scf.RHF(mol) mfr.scf() mcr = mcscf.CASSCF(mfr, 4, 4) mcr.conv_tol_grad = 1e-6 mcr.mc1step()[0] mfu = scf.UHF(mol) mfu.scf() mcu = mcscf.UCASSCF(mfu, 4, 4) mcu.conv_tol_grad = 1e-6 mcu.mc1step()[0] class KnowValues(unittest.TestCase): def test_spin_square(self): ss = mcscf.addons.spin_square(mcr)[0]
def test_nr_rhf_no_mem(self): rhf = scf.RHF(mol) rhf.conv_tol = 1e-11 rhf.max_memory = 0 self.assertAlmostEqual(rhf.scf(), -76.026765673120565, 9)
def test_sort_mo_by_irrep1(self): mol = gto.M(atom='N 0 0 -.45; N 0 0 .45', basis='ccpvdz', symmetry=True, verbose=0) mf = scf.RHF(mol).run() mc1 = mcscf.CASSCF(mf, 6, 6) caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff, { 'A1g': 1, 'A1u': 1, 'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1 }, { 'A1g': 2, 'A1u': 2 }) self.assertEqual(list(caslst), [4, 5, 7, 8, 9, 10]) caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff, { 'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1 }, { 'A1g': 2, 'A1u': 2 }) self.assertEqual(list(caslst), [4, 5, 7, 8, 9, 10]) caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff, { 'E1uy': 1, 'E1ux': 1, 'E1gy': 1, 'E1gx': 1 }, {'A1u': 2}) self.assertEqual(list(caslst), [4, 5, 7, 8, 9, 10]) caslst = mcscf.addons.caslst_by_irrep(mc1, mf.mo_coeff, { 'A1g': 1, 'A1u': 1 }, { 'E1uy': 1, 'E1ux': 1 }) self.assertEqual(list(caslst), [3, 6, 8, 9, 12, 13]) self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff, { 'A1g': 1, 'A1u': 1 }, { 'E1uy': 3, 'E1ux': 3 }) self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff, { 'A1g': 3, 'A1u': 4 }, { 'E1uy': 1, 'E1ux': 1 }) self.assertRaises(ValueError, mcscf.addons.caslst_by_irrep, mc1, mf.mo_coeff, { 'E2ux': 2, 'E2uy': 2 }, { 'E1uy': 1, 'E1ux': 1 })
from pyscf import gto, scf, ao2mo, mcscf, tools, fci, mp from pyscf.shciscf import shci, settings from pyscf.lo import pipek, boys import sys UHF = False r = float(sys.argv[1]) * 0.529177 n = 10 order = 5 atomstring = "" for i in range(n): atomstring += "H 0 0 %g\n" % (i * r) mol = gto.M(atom=atomstring, basis='sto-6g', verbose=4, symmetry=0, spin=0) myhf = scf.RHF(mol) if (UHF): myhf = scf.UHF(mol) print myhf.kernel() if UHF: mocoeff = myhf.mo_coeff[0] else: mocoeff = myhf.mo_coeff lmo = pipek.PM(mol).kernel(mocoeff) #print the atom with which the lmo is associated orbitalOrder = [] for i in range(lmo.shape[1]): orbitalOrder.append(numpy.argmax(numpy.absolute(lmo[:, i])))
mol = gto.Mole() mol.verbose = 0 mol.atom = [ ['H', (1., -1., 0.)], ['H', (0., -1., -1.)], ['H', (1., -0.5, -1.)], ['H', (0., 1., 1.)], ['H', (0., 0.5, 1.)], ['H', (1., 0., -1.)], ] mol.basis = '6-31g' mol.build() nmo = mol.nao_nr() m = newton(scf.RHF(mol)) e0 = m.kernel() ##################################### mol.basis = '6-31g' mol.spin = 2 mol.build(0, 0) m = scf.RHF(mol) m.max_cycle = 1 #m.verbose = 5 m.scf() e1 = kernel(newton(m), m.mo_coeff, m.mo_occ, max_cycle=50, verbose=5)[1] m = scf.UHF(mol) m.max_cycle = 1 #m.verbose = 5
#!/usr/bin/env python ''' Scan HF/DFT PES. ''' import numpy from pyscf import gto from pyscf import scf, dft # # A scanner can take the initial guess from previous calculation # automatically. # mol = gto.Mole() mf_scanner = scf.RHF(mol).as_scanner() ehf1 = [] for b in numpy.arange(0.7, 4.01, 0.1): mol = gto.M(verbose = 5, output = 'out_hf-%2.1f' % b, atom = [["F", (0., 0., 0.)], ["H", (0., 0., b)],], basis = 'cc-pvdz') ehf1.append(mf_scanner(mol)) # # Create a new scanner, the results of last calculation will not be used as # initial guess. # mf_scanner = dft.RKS(mol).set(xc='b3lyp').as_scanner() ehf2 = []
mol = gto.Mole() mol.basis = 'cc-pvtz' mol.atom = ''' N 0.0000 0.0000 0.5488 N 0.0000 0.0000 -0.5488 ''' mol.verbose = 4 mol.spin = 0 mol.symmetry = 1 mol.symmetry_subgroup = 'D2h' mol.charge = 0 mol.build() int3c = df.incore.cholesky_eri(mol, auxbasis='ccpvtz-fit') mf = scf.density_fit(scf.RHF(mol)) mf.with_df._cderi = int3c mf.auxbasis = 'cc-pvtz-fit' mf.conv_tol = 1e-12 mf.direct_scf = 1 mf.level_shift = 0.1 mf.kernel() mc = mcscf.DFCASSCF(mf, 10, 10) mc.fcisolver.tol = 1e-8 mc.fcisolver.max_cycle = 250 mc.max_cycle_macro = 250 mc.max_cycle_micro = 7 mc.fcisolver.nroots = 1 mc.kernel()
idx = numpy.argsort(es) assert (numpy.allclose(es[idx], esub, rtol=1e-3, atol=1e-4)) c[:, degidx] = numpy.hstack(cs)[:, idx] return c if __name__ == '__main__': from pyscf import scf from pyscf import gto from pyscf import mcscf mol = gto.M( verbose=0, atom=''' H 0.000000, 0.500000, 1.5 O 0.000000, 0.000000, 1. O 0.000000, 0.000000, -1. H 0.000000, -0.500000, -1.5''', basis='ccpvdz', ) mf = scf.RHF(mol) mf.scf() aolst = [i for i, s in enumerate(mol.ao_labels()) if 'H 1s' in s] dm = mf.make_rdm1() ncas, nelecas, mo = guess_cas(mf, dm, aolst, verbose=4) mc = mcscf.CASSCF(mf, ncas, nelecas).set(verbose=4) emc = mc.kernel(mo)[0] print(emc, )
By default, the FCI solver will take Mole attribute spin for the spin state. It can be overwritten by passing kwarg ``nelec`` to the kernel function of FCI solver. The nelec argument is a two-element tuple. The first is the number of alpha electrons; the second is the number of beta electrons. If spin-contamination is observed on FCI wavefunction, we can use the decoration function :func:`fci.addons.fix_spin_` to level shift the energy of states which do not have the target spin. ''' import numpy from pyscf import gto, scf, fci mol = gto.M(atom='Ne 0 0 0', basis='631g', spin=2) m = scf.RHF(mol) m.kernel() norb = m.mo_energy.size fs = fci.FCI(mol, m.mo_coeff) e, c = fs.kernel() print('E = %.12f 2S+1 = %.7f' % (e, fs.spin_square(c, norb, (6, 4))[1])) e, c = fs.kernel(nelec=(5, 5)) print('E = %.12f 2S+1 = %.7f' % (e, fs.spin_square(c, norb, (5, 5))[1])) fs = fci.addons.fix_spin_(fci.FCI(mol, m.mo_coeff), shift=.5) e, c = fs.kernel() print('E = %.12f 2S+1 = %.7f' % (e, fs.spin_square(c, norb, (6, 4))[1])) #
from pyscf import scf from pyscf import dft from pyscf import tddft mol = gto.Mole() mol.verbose = 0 mol.output = None mol.atom = [ ['H', (0., 0., 1.804)], ['F', (0., 0., 0.)], ] mol.unit = 'B' mol.basis = '631g' mol.build() mf = scf.RHF(mol).run(conv_tol=1e-14) td = tddft.TDA(mf) td.nstates = 3 e, z = td.kernel() tdg = Gradients(td) #tdg.verbose = 5 g1 = tdg.kernel(z[0]) print(g1) print(lib.finger(g1) - 0.18686561181358813) #[[ 0 0 -2.67023832e-01] # [ 0 0 2.67023832e-01]] td_solver = td.as_scanner() e1 = td_solver(mol.set_geom_('H 0 0 1.805; F 0 0 0', unit='B')) e2 = td_solver(mol.set_geom_('H 0 0 1.803; F 0 0 0', unit='B')) print(abs((e1[0] - e2[0]) / .002 - g1[0, 2]).max())
def test_1e(self): mf = scf.rohf.HF1e(mol) self.assertAlmostEqual(mf.scf(), -23.867818585778764, 9) mf = scf.RHF(gto.M(atom='H', spin=1)) self.assertAlmostEqual(mf.kernel(), -0.46658184955727555, 9)