['H', (0., -0.5, -1.)], ['H', (0., -0.5, -0.)], ['H', (0., -0., -1.)], ['H', (1., -0.5, 0.)], ['H', (0., 1., 1.)], ] mol.basis = { 'H': 'sto-3g', 'O': '6-31g', } mol.charge = 1 mol.spin = 1 mol.build() m = scf.UHF(mol) ehf = m.scf() emc = kernel(umc1step.CASSCF(m, 4, (2, 1)), m.mo_coeff, verbose=4)[1] print(ehf, emc, emc - ehf) print(emc - -2.9782774463926618) 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.charge = 1
self.made_ee_imds = True logger.timer(self, 'EOM-CCSD EE intermediates', *cput0) return self if __name__ == '__main__': from pyscf import scf from pyscf import gto from pyscf.cc import gccsd 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.spin = 0 mol.build() mf = scf.UHF(mol).run() mf = scf.addons.convert_to_ghf(mf) mycc = gccsd.GCCSD(mf) ecc, t1, t2 = mycc.kernel() print(ecc - -0.2133432712431435) e, v = mycc.ipccsd(nroots=8) print(e[0] - 0.4335604332073799) print(e[2] - 0.5187659896045407) print(e[4] - 0.6782876002229172) #mycc.verbose = 5 e, v = mycc.eaccsd(nroots=8) print(e[0] - 0.16737886338859731) print(e[2] - 0.24027613852009164) print(e[4] - 0.51006797826488071)
def _calculate_integrals(mol, hf_method="rhf", conv_tol=1e-9, max_cycle=50, init_guess="minao"): """Function to calculate the one and two electron terms. Perform a Hartree-Fock calculation in the given basis. Args: mol (gto.Mole) : A PySCF gto.Mole object. hf_method (str): rhf, uhf, rohf conv_tol (float): Convergence tolerance max_cycle (int): Max convergence cycles init_guess (str): Initial guess for SCF Returns: QMolecule: QMolecule populated with driver integrals etc Raises: QiskitNatureError: Invalid hf method type """ enuke = gto.mole.energy_nuc(mol) if hf_method == "rhf": m_f = scf.RHF(mol) elif hf_method == "rohf": m_f = scf.ROHF(mol) elif hf_method == "uhf": m_f = scf.UHF(mol) else: raise QiskitNatureError("Invalid hf_method type: {}".format(hf_method)) m_f.conv_tol = conv_tol m_f.max_cycle = max_cycle m_f.init_guess = init_guess ehf = m_f.kernel() logger.info("PySCF kernel() converged: %s, e(hf): %s", m_f.converged, m_f.e_tot) if isinstance(m_f.mo_coeff, tuple): mo_coeff = m_f.mo_coeff[0] mo_coeff_b = m_f.mo_coeff[1] mo_occ = m_f.mo_occ[0] mo_occ_b = m_f.mo_occ[1] else: # With PySCF 1.6.2, instead of a tuple of 2 dimensional arrays, its a 3 dimensional # array with the first dimension indexing to the coeff arrays for alpha and beta if len(m_f.mo_coeff.shape) > 2: mo_coeff = m_f.mo_coeff[0] mo_coeff_b = m_f.mo_coeff[1] mo_occ = m_f.mo_occ[0] mo_occ_b = m_f.mo_occ[1] else: mo_coeff = m_f.mo_coeff mo_coeff_b = None mo_occ = m_f.mo_occ mo_occ_b = None norbs = mo_coeff.shape[0] if isinstance(m_f.mo_energy, tuple): orbs_energy = m_f.mo_energy[0] orbs_energy_b = m_f.mo_energy[1] else: # See PYSCF 1.6.2 comment above - this was similarly changed if len(m_f.mo_energy.shape) > 1: orbs_energy = m_f.mo_energy[0] orbs_energy_b = m_f.mo_energy[1] else: orbs_energy = m_f.mo_energy orbs_energy_b = None if logger.isEnabledFor(logging.DEBUG): # Add some more to PySCF output... # First analyze() which prints extra information about MO energy and occupation mol.stdout.write("\n") m_f.analyze() # Now labelled orbitals for contributions to the MOs for s,p,d etc of each atom mol.stdout.write("\n\n--- Alpha Molecular Orbitals ---\n\n") dump_mat.dump_mo(mol, mo_coeff, digits=7, start=1) if mo_coeff_b is not None: mol.stdout.write("\n--- Beta Molecular Orbitals ---\n\n") dump_mat.dump_mo(mol, mo_coeff_b, digits=7, start=1) mol.stdout.flush() hij = m_f.get_hcore() mohij = np.dot(np.dot(mo_coeff.T, hij), mo_coeff) mohij_b = None if mo_coeff_b is not None: mohij_b = np.dot(np.dot(mo_coeff_b.T, hij), mo_coeff_b) eri = mol.intor("int2e", aosym=1) mo_eri = ao2mo.incore.full(m_f._eri, mo_coeff, compact=False) mohijkl = mo_eri.reshape(norbs, norbs, norbs, norbs) mohijkl_bb = None mohijkl_ba = None if mo_coeff_b is not None: mo_eri_b = ao2mo.incore.full(m_f._eri, mo_coeff_b, compact=False) mohijkl_bb = mo_eri_b.reshape(norbs, norbs, norbs, norbs) mo_eri_ba = ao2mo.incore.general( m_f._eri, (mo_coeff_b, mo_coeff_b, mo_coeff, mo_coeff), compact=False ) mohijkl_ba = mo_eri_ba.reshape(norbs, norbs, norbs, norbs) # dipole integrals mol.set_common_orig((0, 0, 0)) ao_dip = mol.intor_symmetric("int1e_r", comp=3) x_dip_ints = ao_dip[0] y_dip_ints = ao_dip[1] z_dip_ints = ao_dip[2] d_m = m_f.make_rdm1(m_f.mo_coeff, m_f.mo_occ) if not (isinstance(d_m, np.ndarray) and d_m.ndim == 2): d_m = d_m[0] + d_m[1] elec_dip = np.negative(np.einsum("xij,ji->x", ao_dip, d_m).real) elec_dip = np.round(elec_dip, decimals=8) nucl_dip = np.einsum("i,ix->x", mol.atom_charges(), mol.atom_coords()) nucl_dip = np.round(nucl_dip, decimals=8) logger.info("HF Electronic dipole moment: %s", elec_dip) logger.info("Nuclear dipole moment: %s", nucl_dip) logger.info("Total dipole moment: %s", nucl_dip + elec_dip) # Create driver level molecule object and populate _q_ = QMolecule() _q_.origin_driver_version = pyscf_version # Energies and orbits _q_.hf_energy = ehf _q_.nuclear_repulsion_energy = enuke _q_.num_molecular_orbitals = norbs _q_.num_alpha = mol.nelec[0] _q_.num_beta = mol.nelec[1] _q_.mo_coeff = mo_coeff _q_.mo_coeff_b = mo_coeff_b _q_.orbital_energies = orbs_energy _q_.orbital_energies_b = orbs_energy_b _q_.mo_occ = mo_occ _q_.mo_occ_b = mo_occ_b # Molecule geometry _q_.molecular_charge = mol.charge _q_.multiplicity = mol.spin + 1 _q_.num_atoms = mol.natm _q_.atom_symbol = [] _q_.atom_xyz = np.empty([mol.natm, 3]) _ = mol.atom_coords() for n_i in range(0, _q_.num_atoms): xyz = mol.atom_coord(n_i) _q_.atom_symbol.append(mol.atom_pure_symbol(n_i)) _q_.atom_xyz[n_i][0] = xyz[0] _q_.atom_xyz[n_i][1] = xyz[1] _q_.atom_xyz[n_i][2] = xyz[2] # 1 and 2 electron integrals AO and MO _q_.hcore = hij _q_.hcore_b = None _q_.kinetic = mol.intor_symmetric("int1e_kin") _q_.overlap = m_f.get_ovlp() _q_.eri = eri _q_.mo_onee_ints = mohij _q_.mo_onee_ints_b = mohij_b _q_.mo_eri_ints = mohijkl _q_.mo_eri_ints_bb = mohijkl_bb _q_.mo_eri_ints_ba = mohijkl_ba # dipole integrals AO and MO _q_.x_dip_ints = x_dip_ints _q_.y_dip_ints = y_dip_ints _q_.z_dip_ints = z_dip_ints _q_.x_dip_mo_ints = QMolecule.oneeints2mo(x_dip_ints, mo_coeff) _q_.x_dip_mo_ints_b = None _q_.y_dip_mo_ints = QMolecule.oneeints2mo(y_dip_ints, mo_coeff) _q_.y_dip_mo_ints_b = None _q_.z_dip_mo_ints = QMolecule.oneeints2mo(z_dip_ints, mo_coeff) _q_.z_dip_mo_ints_b = None if mo_coeff_b is not None: _q_.x_dip_mo_ints_b = QMolecule.oneeints2mo(x_dip_ints, mo_coeff_b) _q_.y_dip_mo_ints_b = QMolecule.oneeints2mo(y_dip_ints, mo_coeff_b) _q_.z_dip_mo_ints_b = QMolecule.oneeints2mo(z_dip_ints, mo_coeff_b) # dipole moment _q_.nuclear_dipole_moment = nucl_dip _q_.reverse_dipole_sign = True return _q_
mo[:,nocca:nmo], mo[:,nmo+noccb:]]) else: log.note('UHF/UKS wavefunction is stable in the UHF/UKS -> GHF/GKS stability analysis') return mo if __name__ == '__main__': from pyscf import gto, scf, dft mol = gto.M(atom='O 0 0 0; O 0 0 1.2222', basis='631g*') mf = scf.RHF(mol).run() rhf_stability(mf, True, True, verbose=4) mf = dft.RKS(mol).run(level_shift=.2) rhf_stability(mf, True, True, verbose=4) mf = scf.UHF(mol).run() mo1 = uhf_stability(mf, True, True, verbose=4)[0] mf = scf.newton(mf).run(mo1, mf.mo_occ) uhf_stability(mf, True, False, verbose=4) mf = scf.newton(scf.UHF(mol)).run() uhf_stability(mf, True, False, verbose=4) mol.spin = 2 mf = scf.UHF(mol).run() uhf_stability(mf, True, True, verbose=4) mf = dft.UKS(mol).run() uhf_stability(mf, True, True, verbose=4) mol = gto.M(atom='''
def test_nr_uhf(self): mf = scf.UHF(h2o_n) mf.conv_tol = 1e-14 mf.kernel() g = grad.UHF(mf) self.assertAlmostEqual(lib.finger(g.grad_elec()), 4.2250348208172541, 6)
from pyscf import scf from pyscf import ao2mo mol = gto.Mole() mol.verbose = 0 mol.atom = [ ['O', (0., 0., 0.)], ['H', (0., -0.757, 0.587)], ['H', (0., 0.757, 0.587)], ] mol.basis = { 'H': 'sto-3g', 'O': 'sto-3g', } mol.build() mf = scf.UHF(mol).run(conv_tol=1e-14) gmf = scf.addons.convert_to_ghf(mf) myci = GCISD(gmf) eris = myci.ao2mo() ecisd, civec = myci.kernel(eris=eris) print(ecisd - -0.048878084082066106) nmo = eris.mo_coeff.shape[1] rdm1 = myci.make_rdm1(civec, nmo, mol.nelectron) rdm2 = myci.make_rdm2(civec, nmo, mol.nelectron) mo = eris.mo_coeff[:7] + eris.mo_coeff[7:] eri = ao2mo.kernel(mf._eri, mo, compact=False).reshape([nmo] * 4) eri[eris.orbspin[:, None] != eris.orbspin, :, :] = 0 eri[:, :, eris.orbspin[:, None] != eris.orbspin] = 0 h1a = reduce(numpy.dot, (mf.mo_coeff[0].T, mf.get_hcore(), mf.mo_coeff[0]))
make_h1 = make_h1 #TODO: Insert into DF class if __name__ == '__main__': from pyscf import gto from pyscf import scf mol = gto.Mole() mol.verbose = 0 mol.output = None mol.atom = [[1, (1., 0., 0.000)], [1, (0., 1., 0.000)], [1, (0., -1.517, 1.177)], [1, (0., 1.517, 1.177)]] mol.basis = '631g' mol.spin = 2 mol.unit = 'B' mol.build() mf = scf.UHF(mol).density_fit() mf.conv_tol = 1e-14 mf.scf() n3 = mol.natm * 3 hobj = Hessian(mf) e2 = hobj.kernel() ref = scf.UHF(mol).run().Hessian().kernel() print(abs(e2 - ref).max()) print(lib.finger(e2) - -0.23856667321975722) e2 = hobj.set(auxbasis_response=2).kernel() print(abs(e2 - ref).max()) print(lib.finger(e2), -0.72321237584876141)
# symmetry. # mf1 = scf.RHF(mol).newton() dm = mf1.from_chk('cr_atom.chk') mf1.kernel(dm) # # UHF is another way to produce initial guess # charge = 0 spin = 6 mol.basis = 'aug-cc-pvdz' mol.build(False,False) mf = scf.UHF(mol) mf.irrep_nelec = {'Ag': (6,3), 'B1g': (1,0), 'B2g': (1,0), 'B3g': (1,0)} mf.kernel() dm1 = mf.make_rdm1() mf = scf.ROHF(mol) mf.irrep_nelec = {'Ag': (6,3), 'B1g': (1,0), 'B2g': (1,0), 'B3g': (1,0)} mf.kernel(dm1) # # The third way to force the calculation strictly following the correct # configurations is the second order SCF optimizaiton. In the following code, # we call a calculation on cation for a correct HF configuration with spherical # symmetry. This HF configuration is next pass to second order SCF solver # (.newton method) to solve X2C-ROHF model of the open shell atom.
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 m.scf() e2 = 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 m.scf() nrmf = scf.density_fit(newton(m), 'weigend') nrmf.max_cycle = 50 nrmf.conv_tol = 1e-8 nrmf.conv_tol_grad = 1e-5 #nrmf.verbose = 5 e4 = nrmf.kernel()
from pyscf import gto from pyscf import scf from pyscf import dft from pyscf import fci from pyscf import mcscf b = 1.4 mol = gto.M( verbose=7, output='/dev/null', atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]], basis='631g', spin=2, ) m = scf.UHF(mol) m.conv_tol = 1e-10 m.scf() mc = mcscf.UCASCI(m, 5, (4, 2)).run() b = 1.4 molsym = gto.M( verbose=7, output='/dev/null', atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)], [1, (0., 0.757, 0.587)]], basis='631g', spin=2, symmetry=True, ) msym = scf.UHF(molsym)
def automatic_guessing(ase_nuclei,charge,spin,basis,xc,method='FB',ecp=None,newton=True,grid=3,BS=None,calc='UKS',symmetry=False): # ase_nuclei_atoms ... ase.atoms.object containg only nuclei positions # charge ... charge of the system # spin ... spin state of the system # basis ... basis set # xc ... exchange-correlation functional # method ... localization method (FB, ER, PM etc.) # Note: FB seems to give very reasonable guesses. # ecp ... effective core potential file # newton ... second order Newton Raphston scf solver works for LDA and GGA not for SCAN # grid ... grid level # BS ... broken symmetry # calc ,,, UKS or UHF # Performe a DFT calculation. ase_atoms = ase_nuclei if ecp is None: mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,spin=spin,charge=charge,symmetry=symmetry) if ecp is not None: mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,ecp=ecp,spin=spin,charge=charge,symmetry=symmetry) mol.verbose = 4 if calc == 'UKS': mf = scf.UKS(mol) if calc == 'UHF': mf = scf.UHF(mol) if calc == 'RHF': mf = scf.RHF(mol) mf.grids.level = grid mf.max_cycle = 3000 mf.xc = xc # Broken symmetry if BS != None: mf.kernel() idx_flip = mol.search_ao_label(BS) dma, dmb = mf.make_rdm1() dma_flip = dma[idx_flip.reshape(-1,1),idx_flip].copy() dmb_flip= dmb[idx_flip.reshape(-1,1),idx_flip].copy() dma[idx_flip.reshape(-1,1),idx_flip] = dmb_flip dmb[idx_flip.reshape(-1,1),idx_flip] = dma_flip dm = [dma, dmb] if ecp is None: mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,spin=0,charge=charge,symmetry=symmetry) if ecp is not None: mol = gto.M(atom=ase2pyscf(ase_atoms), basis=basis,ecp=ecp,spin=0,charge=charge,symmetry=symmetry) mol.verbose = 4 mf = scf.UKS(mol) mf.grids.level = grid mf.max_cycle = 3000 mf.xc = xc if newton == True: mf = mf.as_scanner() mf = mf.newton() if BS == None: mf.kernel() if BS != None: mf.run(dm) if calc == 'RHF': mf = scf.addons.convert_to_uhf(mf) # Performe a localization calculation. # Both spin channels are localized separately. # The orbitals are written out as cube files. calc_localized_orbitals(mf,mol,method=method) # Collect all cube files per spin channel. f1 = glob.glob('*orb*spin1.cube') f2 = glob.glob('*orb*spin2.cube') # test for nuclei positions # for ASE Version: 3.15.1b1 # we neede the file handle and not the string # new: f_cube = open(f1[0]) ase_atoms = cube.read_cube(f_cube) # previous: ase_atoms = cube.read_cube(f1[0]) f_cube.close() # Calculate the guess. get_guess(atoms=ase_atoms,spin1_cube=f1,spin2_cube=f2,method=method)
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 m.scf() e2 = 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 m.scf() nrmf = scf.density_fit(newton(m)) nrmf.max_cycle = 50 nrmf.conv_tol = 1e-8 nrmf.conv_tol_grad = 1e-5 #nrmf.verbose = 5 e4 = nrmf.kernel()
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 mol = gw.mol if gw.frozen is None: frozen = 0 else: frozen = gw.frozen # only support frozen core assert (isinstance(frozen, int)) nocca, noccb = gw.nocc nmoa, nmob = gw.nmo assert (frozen < nocca and frozen < noccb) if Lpq is None: Lpq = gw.ao2mo(mo_coeff) if orbs is None: orbs = range(nmoa) else: orbs = [x - 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() vj = mf.get_j() v_mf[0] = v_mf[0] - (vj[0] + vj[1]) v_mf[1] = v_mf[1] - (vj[0] + vj[1]) v_mf_frz = np.zeros((2, nmoa - frozen, nmob - frozen)) for s in range(2): v_mf_frz[s] = reduce(numpy.dot, (mo_coeff[s].T, v_mf[s], mo_coeff[s])) v_mf = v_mf_frz # v_hf from DFT/HF density if vhf_df and frozen == 0: # density fitting vk vk = np.zeros_like(v_mf) vk[0] = -einsum('Lni,Lim->nm', Lpq[0, :, :, :nocca], Lpq[0, :, :nocca, :]) vk[1] = -einsum('Lni,Lim->nm', Lpq[1, :, :, :noccb], Lpq[1, :, :noccb, :]) else: # exact vk without density fitting dm = mf.make_rdm1() uhf = scf.UHF(mol) vk = uhf.get_veff(mol, dm) vj = uhf.get_j(mol, dm) vk[0] = vk[0] - (vj[0] + vj[1]) vk[1] = vk[1] - (vj[0] + vj[1]) vk_frz = np.zeros((2, nmoa - frozen, nmob - frozen)) for s in range(2): vk_frz[s] = reduce(numpy.dot, (mo_coeff[s].T, vk[s], mo_coeff[s])) vk = vk_frz # 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_a = AC_twopole_diag(sigmaI[0], omega[0], orbs, nocca) coeff_b = AC_twopole_diag(sigmaI[1], omega[1], orbs, noccb) elif gw.ac == 'pade': coeff_a, omega_fit_a = AC_pade_thiele_diag(sigmaI[0], omega[0]) coeff_b, omega_fit_b = AC_pade_thiele_diag(sigmaI[1], omega[1]) omega_fit = np.asarray((omega_fit_a, omega_fit_b)) coeff = np.asarray((coeff_a, coeff_b)) conv = True h**o = max(mo_energy[0][nocca - 1], mo_energy[1][noccb - 1]) lumo = min(mo_energy[0][nocca], mo_energy[1][noccb]) ef = (h**o + lumo) / 2. mf_mo_energy = mo_energy.copy() mo_energy = np.zeros_like(np.asarray(gw._scf.mo_energy)) for s in range(2): for p in orbs: if gw.linearized: # linearized G0W0 de = 1e-6 ep = mf_mo_energy[s][p] #TODO: analytic sigma derivative if gw.ac == 'twopole': sigmaR = two_pole(ep - ef, coeff[s, :, p - orbs[0]]).real dsigma = two_pole(ep - ef + de, coeff[s, :, p - orbs[0]]).real - sigmaR.real elif gw.ac == 'pade': sigmaR = pade_thiele(ep - ef, omega_fit[s, p - orbs[0]], coeff[s, :, p - orbs[0]]).real dsigma = pade_thiele( ep - ef + de, omega_fit[s, p - orbs[0]], coeff[s, :, p - orbs[0]]).real - sigmaR.real zn = 1.0 / (1.0 - dsigma / de) e = ep + zn * (sigmaR.real + vk[s, p, p] - v_mf[s, p, p]) mo_energy[s, p + frozen] = e else: # self-consistently solve QP equation def quasiparticle(omega): if gw.ac == 'twopole': sigmaR = two_pole(omega - ef, coeff[s, :, p - orbs[0]]).real elif gw.ac == 'pade': sigmaR = pade_thiele(omega - ef, omega_fit[s, p - orbs[0]], coeff[s, :, p - orbs[0]]).real return omega - mf_mo_energy[s][p] - ( sigmaR.real + vk[s, p, p] - v_mf[s, p, p]) try: e = newton(quasiparticle, mf_mo_energy[s][p], tol=1e-6, maxiter=100) mo_energy[s, p + frozen] = e except RuntimeError: conv = False mo_coeff = gw._scf.mo_coeff if gw.verbose >= logger.DEBUG: numpy.set_printoptions(threshold=nmoa) logger.debug(gw, ' GW mo_energy spin-up =\n%s', mo_energy[0]) logger.debug(gw, ' GW mo_energy spin-down =\n%s', mo_energy[1]) numpy.set_printoptions(threshold=1000) return conv, mo_energy, mo_coeff
def test(): """ Ensure that DMC obtains the exact result for a hydrogen atom """ from pyscf import gto, scf from pyqmc.jastrowspin import JastrowSpin from pyqmc.dmc import limdrift, rundmc from pyqmc.mc import vmc from pyqmc.accumulators import EnergyAccumulator from pyqmc.func3d import CutoffCuspFunction from pyqmc.multiplywf import MultiplyWF from pyqmc.coord import OpenConfigs from pyqmc import Slater import pandas as pd mol = gto.M(atom="H 0. 0. 0.", basis="sto-3g", unit="bohr", spin=1) mf = scf.UHF(mol).run() nconf = 1000 configs = OpenConfigs(np.random.randn(nconf, 1, 3)) wf1 = Slater(mol, mf) wf = wf1 wf2 = JastrowSpin(mol, a_basis=[CutoffCuspFunction(5, 0.2)], b_basis=[]) wf2.parameters["acoeff"] = np.asarray([[[1.0, 0]]]) wf = MultiplyWF(wf1, wf2) dfvmc, configs_ = vmc(wf, configs, nsteps=50, accumulators={"energy": EnergyAccumulator(mol)}) dfvmc = pd.DataFrame(dfvmc) print( "vmc energy", np.mean(dfvmc["energytotal"]), np.std(dfvmc["energytotal"]) / np.sqrt(len(dfvmc)), ) warmup = 200 branchtime = 5 dfdmc, configs_, weights_ = rundmc( wf, configs, nsteps=4000 + warmup * branchtime, branchtime=branchtime, accumulators={"energy": EnergyAccumulator(mol)}, ekey=("energy", "total"), tstep=0.01, drift_limiter=limdrift, verbose=True, ) dfdmc = pd.DataFrame(dfdmc) dfdmc.sort_values("step", inplace=True) dfprod = dfdmc[dfdmc.step >= warmup] rb_summary = reblock.reblock_summary(dfprod[["energytotal", "energyei"]], 20) print(rb_summary) energy, err = [ rb_summary[v]["energytotal"] for v in ("mean", "standard error") ] assert (np.abs(energy + 0.5) < 5 * err), "energy not within {0} of -0.5: energy {1}".format( 5 * err, np.mean(energy))
from pyscf.grad import tduhf as tduhf_grad mol = gto.Mole() mol.verbose = 5 mol.output = '/dev/null' mol.atom = [ ['H', (0., 0., 1.804)], ['F', (0., 0., 0.)], ] mol.unit = 'B' mol.charge = 2 mol.spin = 2 mol.basis = '631g' mol.build() pmol = mol.copy() mf = scf.UHF(mol).set(conv_tol=1e-12).run() def tearDownModule(): global mol, pmol, mf mol.stdout.close() del mol, pmol, mf class KnownValues(unittest.TestCase): def test_tda(self): td = tdscf.TDA(mf).run(nstates=3) tdg = td.nuc_grad_method() g1 = tdg.kernel(state=3) self.assertAlmostEqual(g1[0, 2], -0.78246882668628404, 7)