def run_hf(xyz,
basis,
charge=0,
multiplicity=1,
conv_tol=1e-12,
conv_tol_grad=1e-8,
max_iter=150):
mol = gto.M(
atom=xyz,
basis=basis,
unit="Bohr",
# spin in the pyscf world is 2S
spin=multiplicity - 1,
charge=charge,
# Disable commandline argument parsing in pyscf
parse_arg=False,
dump_input=False,
verbose=0,
)
mf = scf.HF(mol)
mf.conv_tol = conv_tol
mf.conv_tol_grad = conv_tol_grad
mf.max_cycle = max_iter
# since we want super tight convergence for tests,
# tweak the options for non-RHF systems
if multiplicity != 1:
mf.max_cycle += 500
mf.diis = scf.EDIIS()
mf.diis_space = 3
mf = scf.addons.frac_occ(mf)
mf.kernel()
return mf
def calc_hf(mol, **scfargs):
mf = scf.HF(mol).run(**scfargs)
if not mf.converged:
raise RuntimeError("SCF not converged!")
etot = mf.e_tot
grad = mf.nuc_grad_method().kernel()
rdm = mf.make_rdm1()
return etot, -grad / BOHR, rdm
def calc_mp2(mol, **scfargs):
import pyscf.mp
mf = scf.HF(mol).run(**scfargs)
if not mf.converged:
raise RuntimeError("SCF not converged!")
postmf = pyscf.mp.MP2(mf).run()
etot = postmf.e_tot
grad = postmf.nuc_grad_method().kernel()
return etot, -grad / BOHR, None
def init_guess_mixed(mol, mixing_parameter=numpy.pi / 4):
''' Copy from pyscf/examples/scf/56-h2_symm_breaking.py
Generate density matrix with broken spatial and spin symmetry by mixing
H**O and LUMO orbitals following ansatz in Szabo and Ostlund, Sec 3.8.7.
psi_1a = numpy.cos(q)*psi_homo + numpy.sin(q)*psi_lumo
psi_1b = numpy.cos(q)*psi_homo - numpy.sin(q)*psi_lumo
psi_2a = -numpy.sin(q)*psi_homo + numpy.cos(q)*psi_lumo
psi_2b = numpy.sin(q)*psi_homo + numpy.cos(q)*psi_lumo
Returns:
Density matrices, a list of 2D ndarrays for alpha and beta spins
'''
# opt: q, mixing parameter 0 < q < 2 pi
# based on init_guess_by_1e
h1e = scf.hf.get_hcore(mol)
s1e = scf.hf.get_ovlp(mol)
mo_energy, mo_coeff = scf.hf.eig(h1e, s1e)
mf = scf.HF(mol)
mo_occ = mf.get_occ(mo_energy=mo_energy, mo_coeff=mo_coeff)
homo_idx = 0
lumo_idx = 1
for i in range(len(mo_occ) - 1):
if mo_occ[i] > 0 and mo_occ[i + 1] < 0:
homo_idx = i
lumo_idx = i + 1
psi_homo = mo_coeff[:, homo_idx]
psi_lumo = mo_coeff[:, lumo_idx]
Ca = numpy.zeros_like(mo_coeff)
Cb = numpy.zeros_like(mo_coeff)
# mix h**o and lumo of alpha and beta coefficients
q = mixing_parameter
for k in range(mo_coeff.shape[0]):
if k == homo_idx:
Ca[:, k] = numpy.cos(q) * psi_homo + numpy.sin(q) * psi_lumo
Cb[:, k] = numpy.cos(q) * psi_homo - numpy.sin(q) * psi_lumo
continue
if k == lumo_idx:
Ca[:, k] = -numpy.sin(q) * psi_homo + numpy.cos(q) * psi_lumo
Cb[:, k] = numpy.sin(q) * psi_homo + numpy.cos(q) * psi_lumo
continue
Ca[:, k] = mo_coeff[:, k]
Cb[:, k] = mo_coeff[:, k]
dm = scf.UHF(mol).make_rdm1((Ca, Cb), (mo_occ, mo_occ))
return dm
def calc_ccsd_t(mol, **scfargs):
import pyscf.cc
import pyscf.grad.ccsd_t as ccsd_t_grad
mf = scf.HF(mol).run(**scfargs)
if not mf.converged:
raise RuntimeError("SCF not converged!")
mycc = mf.CCSD().run()
et_correction = mycc.ccsd_t()
etot = mycc.e_tot + et_correction
grad = ccsd_t_grad.Gradients(mycc).kernel()
return etot, -grad / BOHR, None
def calc_ccsd(mol, **scfargs):
import pyscf.cc
mf = scf.HF(mol).run(**scfargs)
if not mf.converged:
raise RuntimeError("SCF not converged!")
mycc = mf.CCSD().run()
etot = mycc.e_tot
grad = mycc.nuc_grad_method().kernel()
ccdm = np.einsum('pi,ij,qj->pq', mf.mo_coeff, mycc.make_rdm1(),
mf.mo_coeff.conj())
return etot, -grad / BOHR, ccdm
def test_getattr(self):
from pyscf import scf, dft, ci, tdscf
mol = gto.M(atom='He')
self.assertEqual(mol.HF().__class__, scf.HF(mol).__class__)
self.assertEqual(mol.KS().__class__, dft.KS(mol).__class__)
self.assertEqual(mol.UKS().__class__, dft.UKS(mol).__class__)
self.assertEqual(mol.CISD().__class__, ci.cisd.RCISD)
self.assertEqual(mol.TDA().__class__, tdscf.rhf.TDA)
self.assertEqual(mol.dTDA().__class__, tdscf.rks.dTDA)
self.assertEqual(mol.TDBP86().__class__, tdscf.rks.TDDFTNoHybrid)
self.assertEqual(mol.TDB3LYP().__class__, tdscf.rks.TDDFT)
self.assertRaises(AttributeError, lambda: mol.xyz)
self.assertRaises(AttributeError, lambda: mol.TDxyz)
def _pyscf_qm(qm_atnm, qm_crds, qm_basis, qm_chg_tot, esp_opts={}):
atm_list = []
for ia, xyz in enumerate(qm_crds):
sym = qm_atnm[ia] # .split(':')[0]
atm_list.append([sym, (xyz[0], xyz[1], xyz[2])])
#print(ia, sym, xyz)
#print('qm_chg_tot', qm_chg_tot)
qm_mol = _pyscf_mol_build(atm_list, qm_basis, qm_chg_tot)
mf = scf.HF(qm_mol).run()
ener_QM = mf.e_tot
grds_QM = mf.Gradients().kernel()
dm = mf.make_rdm1()
esp_chg = esp_atomic_charges(qm_mol, dm, esp_opts)
return ener_QM, grds_QM, esp_chg
def test_init(self):
from pyscf import dft
from pyscf import x2c
mol_r = mol
mol_u = gto.M(atom='Li', spin=1, verbose=0)
mol_r1 = gto.M(atom='H', spin=1, verbose=0)
sym_mol_r = molsym
sym_mol_u = gto.M(atom='Li', spin=1, symmetry=1, verbose=0)
sym_mol_r1 = gto.M(atom='H', spin=1, symmetry=1, verbose=0)
self.assertTrue(isinstance(scf.RKS(mol_r), dft.rks.RKS))
self.assertTrue(isinstance(scf.RKS(mol_u), dft.roks.ROKS))
self.assertTrue(isinstance(scf.UKS(mol_r), dft.uks.UKS))
self.assertTrue(isinstance(scf.ROKS(mol_r), dft.roks.ROKS))
self.assertTrue(isinstance(scf.GKS(mol_r), dft.gks.GKS))
self.assertTrue(isinstance(scf.KS(mol_r), dft.rks.RKS))
self.assertTrue(isinstance(scf.KS(mol_u), dft.uks.UKS))
self.assertTrue(isinstance(scf.RHF(mol_r), scf.hf.RHF))
self.assertTrue(isinstance(scf.RHF(mol_u), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.RHF(mol_r1), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.UHF(mol_r), scf.uhf.UHF))
self.assertTrue(isinstance(scf.UHF(mol_u), scf.uhf.UHF))
self.assertTrue(isinstance(scf.UHF(mol_r1), scf.uhf.HF1e))
self.assertTrue(isinstance(scf.ROHF(mol_r), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.ROHF(mol_u), scf.rohf.ROHF))
self.assertTrue(isinstance(scf.ROHF(mol_r1), scf.rohf.HF1e))
self.assertTrue(isinstance(scf.HF(mol_r), scf.hf.RHF))
self.assertTrue(isinstance(scf.HF(mol_u), scf.uhf.UHF))
self.assertTrue(isinstance(scf.HF(mol_r1), scf.rohf.HF1e))
self.assertTrue(isinstance(scf.GHF(mol_r), scf.ghf.GHF))
self.assertTrue(isinstance(scf.GHF(mol_u), scf.ghf.GHF))
self.assertTrue(isinstance(scf.GHF(mol_r1), scf.ghf.HF1e))
#TODO: self.assertTrue(isinstance(scf.DHF(mol_r), scf.dhf.RHF))
self.assertTrue(isinstance(scf.DHF(mol_u), scf.dhf.UHF))
self.assertTrue(isinstance(scf.DHF(mol_r1), scf.dhf.HF1e))
self.assertTrue(isinstance(scf.RHF(sym_mol_r), scf.hf_symm.RHF))
self.assertTrue(isinstance(scf.RHF(sym_mol_u), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.RHF(sym_mol_r1), scf.hf_symm.HF1e))
self.assertTrue(isinstance(scf.UHF(sym_mol_r), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.UHF(sym_mol_u), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.UHF(sym_mol_r1), scf.uhf_symm.HF1e))
self.assertTrue(isinstance(scf.ROHF(sym_mol_r), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.ROHF(sym_mol_u), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.ROHF(sym_mol_r1), scf.hf_symm.HF1e))
self.assertTrue(isinstance(scf.HF(sym_mol_r), scf.hf_symm.RHF))
self.assertTrue(isinstance(scf.HF(sym_mol_u), scf.uhf_symm.UHF))
self.assertTrue(isinstance(scf.HF(sym_mol_r1), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_r), scf.ghf_symm.GHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_u), scf.ghf_symm.GHF))
self.assertTrue(isinstance(scf.GHF(sym_mol_r1), scf.ghf_symm.HF1e))
self.assertTrue(isinstance(scf.X2C(mol_r), x2c.x2c.UHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_r)), scf.rhf.RHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_u)), scf.uhf.UHF))
self.assertTrue(isinstance(scf.sfx2c1e(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.sfx2c1e(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.density_fit(scf.HF(mol_r)),
scf.rhf.RHF))
self.assertTrue(isinstance(scf.density_fit(scf.HF(mol_u)),
scf.uhf.UHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.density_fit(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_r)), scf.rhf.RHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_u)), scf.uhf.UHF))
self.assertTrue(isinstance(scf.newton(scf.HF(mol_r1)), scf.rohf.ROHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_r)), scf.rhf_symm.RHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_u)), scf.uhf_symm.UHF))
self.assertTrue(
isinstance(scf.newton(scf.HF(sym_mol_r1)), scf.hf_symm.ROHF))
.kernel() function is the simple way to call HF driver.
.analyze() function calls the Mulliken population analysis etc.
'''
import pyscf
mol = pyscf.M(
atom='H 0 0 0; F 0 0 1.1', # in Angstrom
basis='ccpvdz',
symmetry=True,
)
myhf = mol.HF()
myhf.kernel()
# Orbital energies, Mulliken population etc.
myhf.analyze()
#
# myhf object can also be created using the APIs of gto, scf module
#
from pyscf import gto, scf
mol = gto.M(
atom='H 0 0 0; F 0 0 1.1', # in Angstrom
basis='ccpvdz',
symmetry=True,
)
myhf = scf.HF(mol)
myhf.kernel()
#
#
#
# ------------------------------------------------------------------------
print('============================================================')
print()
print(' Resultados del SCF ')
print('(Todos los resultados estan en unidades atomicas)')
print()
print('============================================================')
print(' ')
nao = mol.nao
print('Numero de Orbitales Atomicos (nao): ', nao)
print('-------------------------------------------')
print()
mf = scf.HF(mol)
mf.kernel()
print()
print('--------------------------')
print('Molecular Energies: (moe) ')
print('--------------------------')
print()
moe = mf.mo_energy
print(moe)
print()
print('-------------------------------')
print('Molecular coeficients: (cmos)')
print('-------------------------------')
print('Orb moleculares en columnas, \psi_a en la columna a')
print()
