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)
