_write(self.stdout, para_occ[i], 'occ part of para-magnetism')
_write(self.stdout, para_vir[i], 'vir part of para-magnetism')
return e11
dia = dia
para = para
get_fock = get_fock
solve_mo1 = solve_mo1
def get_ovlp(self, mol=None, gauge_orig=None):
if mol is None: mol = self.mol
if gauge_orig is None: gauge_orig = self.gauge_orig
return get_ovlp(mol, gauge_orig)
from pyscf import scf
scf.hf.RHF.NMR = lib.class_as_method(NMR)
def _write(stdout, msc3x3, title):
stdout.write('%s\n' % title)
stdout.write('B_x %s\n' % str(msc3x3[0]))
stdout.write('B_y %s\n' % str(msc3x3[1]))
stdout.write('B_z %s\n' % str(msc3x3[2]))
stdout.flush()
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
e2 = rhf_g._safe_solve(im, e2)
return -4 * nist.PROTON_MASS_AU * e2
else:
return rhf_g.dia(magobj, gauge_orig)
class RotationalGTensor(rhf_g.RotationalGTensor):
'''Rotational g-tensors for RKS'''
dia = dia
get_fock = rks_nmr.get_fock
solve_mo1 = rks_nmr.solve_mo1
from pyscf import lib
from pyscf import dft
dft.rks.RKS.RotationalGTensor = dft.rks_symm.RKS.RotationalGTensor = lib.class_as_method(
RotationalGTensor)
if __name__ == '__main__':
from pyscf import lib
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. .917
F , 0. 0. 0.
'''
mol.basis = 'ccpvdz'
mol.build()
mf = dft.RKS(mol).run(xc='b3lyp')
with_cphf=None):
if with_cphf is None:
with_cphf = nmrobj.cphf
libxc = nmrobj._scf._numint.libxc
with_cphf = with_cphf and libxc.is_hybrid_xc(nmrobj._scf.xc)
return uhf_nmr.solve_mo1(nmrobj, mo_energy, mo_coeff, mo_occ, h1, s1,
with_cphf)
class NMR(uhf_nmr.NMR):
get_fock = get_fock
solve_mo1 = solve_mo1
from pyscf import dft
dft.uks.UKS.NMR = dft.uks_symm.UKS.NMR = lib.class_as_method(NMR)
del (dft)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
['Ne', (0., 0., 0.)],
]
mol.basis = '631g'
mol.build()
mag_para = rhf_g._safe_solve(im, mag_para)
# unit = hbar/mu_N, mu_N is nuclear magneton
unit = -2 * nist.PROTON_MASS_AU
return mag_para * unit
class RotationalGTensor(rhf_g.RotationalGTensor):
'''Rotational g-tensors for UHF'''
dia = dia
para = para
get_fock = uhf_nmr.get_fock
from pyscf import scf
scf.uhf.UHF.RotationalGTensor = lib.class_as_method(RotationalGTensor)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. .917
F , 0. 0. 0.
'''
mol.basis = 'ccpvdz'
mol.build()
mf = scf.UHF(mol).run()
rotg = mf.RotationalGTensor()
def density_fit(self):
raise NotImplementedError
def nuc_grad_method(self):
from pyscf.grad import cisd
return cisd.Gradients(self)
class RCISD(CISD):
pass
from pyscf import scf
scf.hf.RHF.CISD = lib.class_as_method(RCISD)
scf.rohf.ROHF.CISD = None
def _cp(a):
return numpy.array(a, copy=False, order='C')
if __name__ == '__main__':
from pyscf import gto
from pyscf import ao2mo
mol = gto.Mole()
mol.verbose = 0
mol.atom = [
['O', (0., 0., 0.)],
if v1ao is not None: v1ao[1:] *= -1
if k1ao is not None: k1ao[1:] *= -1
return f1vo, f1oo, v1ao, k1ao
class Gradients(tdrhf.Gradients):
@lib.with_doc(grad_elec.__doc__)
def grad_elec(self, xy, singlet, atmlst=None):
return grad_elec(self, xy, singlet, atmlst, self.max_memory,
self.verbose)
Grad = Gradients
from pyscf import tdscf
tdscf.rks.TDA.Gradients = tdscf.rks.TDDFT.Gradients = lib.class_as_method(
Gradients)
if __name__ == '__main__':
from pyscf import gto
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'
de = self.grad_elec(mo_energy, mo_coeff, mo_occ, atmlst)
self.de = de + self.grad_nuc(atmlst=atmlst)
if self.mol.symmetry:
self.de = self.symmetrize(self.de, atmlst)
logger.timer(self, 'SCF gradients', *cput0)
self._finalize()
return self.de
as_scanner = as_scanner
Grad = Gradients
from pyscf import scf
# Inject to RHF class
scf.hf.RHF.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.atom = [
['He', (0., 0., 0.)],
]
mol.basis = {'He': 'ccpvdz'}
mol.build()
method = scf.RHF(mol)
method.scf()
g = Gradients(method)
print(g.grad())
if nocc is None: nocc = self.nocc
if nmo is None: nmo = self.nmo
nocca, noccb = nocc
nmoa, nmob = nmo
nvira, nvirb = nmoa-nocca, nmob-noccb
sizea = nocca * nvira + nocca*(nocca-1)//2*nvira*(nvira-1)//2
sizeb = noccb * nvirb + noccb*(noccb-1)//2*nvirb*(nvirb-1)//2
sizeab = nocca * noccb * nvira * nvirb
return sizea + sizeb + sizeab
def amplitudes_from_rccsd(self, t1, t2):
return amplitudes_from_rccsd(t1, t2)
CCSD = UCCSD
from pyscf import scf
scf.uhf.UHF.CCSD = lib.class_as_method(CCSD)
class _ChemistsERIs(ccsd._ChemistsERIs):
def __init__(self, mol=None):
ccsd._ChemistsERIs.__init__(self, mol)
self.OOOO = None
self.OVOO = None
self.OVOV = None
self.OOVV = None
self.OVVO = None
self.OVVV = None
self.VVVV = None
self.ooOO = None
self.ovOO = None
h1ao = ipipv + ipvip # (nabla i | r/r^3 | j)
h1ao = h1ao + h1ao.transpose(0,1,3,2)
coords = mol.atom_coord(atm_id).reshape(1, 3)
ao = mol.eval_gto('GTOval_ip', coords, comp=3)
fc = 4*numpy.pi/3 * numpy.einsum('dip,diq->pq', ao, ao)
h1ao[0,0] += fc
h1ao[1,1] += fc
h1ao[2,2] += fc
return h1ao
EFG = kernel
from pyscf import scf
scf.hf.RHF.EFG = scf.rohf.ROHF.EFG = scf.uhf.UHF.EFG = lib.class_as_method(EFG)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf, dft
mol = gto.Mole()
mol.verbose = 4
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 = 'ccpvdz'
log.info('CPHF max_cycle_cphf = %d', self.max_cycle_cphf)
if not self._scf.converged:
log.warn('Ground state SCF is not converged')
return self
def kernel(self, mo1=None):
assert(uhf_ssc.ZZ_ONLY)
return uhf_ssc.SpinSpinCoupling.kernel(self, mo1)
SSC = SpinSpinCoupling
from pyscf import lib
from pyscf import dft
dft.uks.UKS.SSC = dft.uks.UKS.SpinSpinCoupling = \
dft.uks_symm.UKS.SSC = dft.uks_symm.UKS.SpinSpinCoupling = \
lib.class_as_method(SSC)
if __name__ == '__main__':
from pyscf import lib, gto, dft
mol = gto.M(atom='''
O 0 0 0
H 0 -0.757 0.587
H 0 0.757 0.587''',
basis='6-31g')
mf1 = dft.UKS(mol).set(xc='b3lyp').run()
ssc = mf1.SSC()
ssc.with_fc = True
ssc.with_fcsd = True
jj = ssc.kernel()
'''
Non-relativistic nuclear spin-rotation tensors for UKS
'''
from pyscf.prop.nsr import uhf as uhf_nsr
from pyscf.prop.nmr import uks as uks_nmr
class NSR(uhf_nsr.NSR):
'''Nuclear-spin rotation tensors for UKS'''
get_fock = uks_nmr.get_fock
solve_mo1 = uks_nmr.solve_mo1
from pyscf import lib
from pyscf import dft
dft.uks.UKS.NSR = dft.uks_symm.UKS.NSR = lib.class_as_method(NSR)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
from pyscf import lib
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. 0.917
f , 0. 0. 0.
'''
mol.basis = 'dzp'
mol.build()
fc = numpy.einsum('ij,ji->', fcLL, dm[:n2c,:n2c])
fc+= numpy.einsum('ij,ji->', fcSS, dm[n2c:,n2c:])
efg_e = fcsd - 8*numpy.pi/3 * numpy.eye(3) * fc
efg_nuc = rhf_efg._get_quad_nuc(mol, atm_id)
v = efg_nuc - efg_e
efg.append(v)
rhf_efg._analyze(mol, atm_id, v, log)
return numpy.asarray(efg)
EFG = kernel
from pyscf import scf
scf.dhf.UHF.EFG = lib.class_as_method(EFG)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf, dft
mol = gto.Mole()
mol.verbose = 4
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 = 'ccpvdz'
TDDFTNoHybrid.__init__(self, mf)
TDH = dRPA
class dTDA(TDA):
def __init__(self, mf):
if not getattr(mf, 'xc', None):
raise RuntimeError("direct TDA can only be applied with DFT; for HF+dTDA, use .xc='hf'")
from pyscf import scf
mf = scf.addons.convert_to_uhf(mf)
mf.xc = ''
TDA.__init__(self, mf)
from pyscf import dft
dft.uks.UKS.TDA = dft.uks_symm.UKS.TDA = lib.class_as_method(TDA)
dft.uks.UKS.TDHF = dft.uks_symm.UKS.TDHF = None
dft.uks.UKS.TDDFT = dft.uks_symm.UKS.TDDFT = lib.class_as_method(TDDFT)
dft.uks.UKS.TDDFTNoHybrid = dft.uks_symm.UKS.TDDFTNoHybrid = lib.class_as_method(TDDFTNoHybrid)
dft.uks.UKS.dTDA = dft.uks_symm.UKS.dTDA = lib.class_as_method(dTDA)
dft.uks.UKS.dRPA = dft.uks_symm.UKS.dRPA = lib.class_as_method(dRPA)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
method, the grid response in DFT numerical integration can be put in
this function.
'''
if self.grid_response:
vhf = envs['vhf']
log = envs['log']
log.debug('grids response for atom %d %s',
atom_id, vhf.exc1_grid[atom_id])
return vhf.exc1_grid[atom_id]
else:
return 0
Grad = Gradients
from pyscf import dft
dft.uks.UKS.Gradients = dft.uks_symm.UKS.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.atom = [
['O' , (0. , 0. , 0.)],
[1 , (0. , -0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)] ]
mol.basis = '631g'
mol.charge = 1
mol.spin = 1
mol.build()
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------------- %s gradients ---------------',
self.base.__class__.__name__)
self._write(self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
from pyscf import mcscf
mcscf.mc1step.CASSCF.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import mcscf
mol = gto.Mole()
mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run()
mc = mcscf.CASSCF(mf, 4, 4).run()
de = mc.Gradients().kernel()
print(lib.finger(de) - 0.019602220578635747)
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.note('Excited State energies (eV)\n%s', self.e * nist.HARTREE2EV)
return self.e, self.xy
def nuc_grad_method(self):
from pyscf.grad import tdrhf
return tdrhf.Gradients(self)
RPA = TDRHF = TDHF
from pyscf import scf
scf.hf.RHF.TDA = lib.class_as_method(TDA)
scf.hf.RHF.TDHF = lib.class_as_method(TDHF)
scf.rohf.ROHF.TDA = None
scf.rohf.ROHF.TDHF = None
scf.hf_symm.ROHF.TDA = None
scf.hf_symm.ROHF.TDHF = None
del(OUTPUT_THRESHOLD)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
class TDDFTNoHybrid(uks.TDDFTNoHybrid):
def gen_vind(self, mf):
vind, hdiag = uks.TDDFTNoHybrid.gen_vind(self, mf)
def vindp(x):
with lib.temporary_env(mf, exxdiv=None):
return vind(x)
return vindp, hdiag
def nuc_grad_method(self):
raise NotImplementedError
def tddft(mf):
'''Driver to create TDDFT or TDDFTNoHybrid object'''
if mf._numint.libxc.is_hybrid_xc(mf.xc):
return TDDFT(mf)
else:
return TDDFTNoHybrid(mf)
from pyscf.pbc import dft
dft.uks.UKS.TDA = lib.class_as_method(TDA)
dft.uks.UKS.TDHF = None
dft.uks.UKS.TDDFT = tddft
#dft.rks.RKS.dTDA = lib.class_as_method(dTDA)
#dft.rks.RKS.dRPA = lib.class_as_method(dRPA)
mymp = dfmp2.DFMP2(self._scf, self.frozen, self.mo_coeff, self.mo_occ)
if with_df is not None:
mymp.with_df = with_df
if mymp.with_df.auxbasis != auxbasis:
mymp.with_df = copy.copy(mymp.with_df)
mymp.with_df.auxbasis = auxbasis
return mymp
def nuc_grad_method(self):
from pyscf.grad import mp2
return mp2.Gradients(self)
RMP2 = MP2
from pyscf import scf
scf.hf.RHF.MP2 = lib.class_as_method(MP2)
scf.rohf.ROHF.MP2 = None
def _mo_energy_without_core(mp, mo_energy):
return mo_energy[get_frozen_mask(mp)]
def _mo_without_core(mp, mo):
return mo[:,get_frozen_mask(mp)]
def _mem_usage(nocc, nvir):
nmo = nocc + nvir
basic = ((nocc*nvir)**2 + nocc*nvir**2*2)*8 / 1e6
incore = nocc*nvir*nmo**2/2*8 / 1e6 + basic
outcore = basic
return incore, outcore, basic
_write(self.stdout, para_occ[i], 'occ part of para-magnetism')
_write(self.stdout, para_vir[i], 'vir part of para-magnetism')
return e11
dia = dia
para = para
get_fock = get_fock
solve_mo1 = solve_mo1
def get_ovlp(self, mol=None, gauge_orig=None):
if mol is None: mol = self.mol
if gauge_orig is None: gauge_orig = self.gauge_orig
return get_ovlp(mol, gauge_orig)
from pyscf import scf
scf.hf.RHF.NMR = lib.class_as_method(NMR)
def _write(stdout, msc3x3, title):
stdout.write('%s\n' % title)
stdout.write('B_x %s\n' % str(msc3x3[0]))
stdout.write('B_y %s\n' % str(msc3x3[1]))
stdout.write('B_z %s\n' % str(msc3x3[2]))
stdout.flush()
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mf_grad, verbose=log)
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------------- %s gradients ---------------',
self.base.__class__.__name__)
rhf_grad._write(self, self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
ccsd.CCSD.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.M(
atom = [
["O" , (0. , 0. , 0.)],
[1 , (0. ,-0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)]],
basis = '631g'
)
mf = scf.RHF(mol).run()
mycc = ccsd.CCSD(mf).run()
def update_amps(self, t2, eris):
raise NotImplementedError
def init_amps(self,
mo_energy=None,
mo_coeff=None,
eris=None,
with_t2=WITH_T2):
return kernel(self, mo_energy, mo_coeff, eris, with_t2)
MP2 = DFMP2
from pyscf import scf
scf.hf.RHF.DFMP2 = lib.class_as_method(DFMP2)
scf.rohf.ROHF.DFMP2 = None
scf.uhf.UHF.DFMP2 = None
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()
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------- %s gradients for state %d ----------',
self.base.__class__.__name__, self.state)
rhf_grad._write(self, self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
from pyscf import tdscf
tdscf.rhf.TDA.Gradients = tdscf.rhf.TDHF.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
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'
for k, occ in enumerate(mo_occ[0]):
no = numpy.count_nonzero(occ > 0)
nv = occ.size - no
p0, p1 = p1, p1 + no * nv
za.append(vo[p0:p1].reshape(no, nv))
for k, occ in enumerate(mo_occ[1]):
no = numpy.count_nonzero(occ > 0)
nv = occ.size - no
p0, p1 = p1, p1 + no * nv
zb.append(vo[p0:p1].reshape(no, nv))
return za, zb
from pyscf.pbc import scf
scf.kuhf.KUHF.TDA = lib.class_as_method(KTDA)
scf.kuhf.KUHF.TDHF = lib.class_as_method(KTDHF)
if __name__ == '__main__':
from pyscf.pbc import gto
from pyscf.pbc import scf
from pyscf.pbc import df
cell = gto.Cell()
cell.unit = 'B'
cell.atom = '''
C 0. 0. 0.
C 1.68506879 1.68506879 1.68506879
'''
cell.a = '''
0. 3.37013758 3.37013758
3.37013758 0. 3.37013758
mem_now = lib.current_memory()[0]
if (self._scf._eri is not None and
(mem_incore+mem_now < self.max_memory) or self.mol.incore_anyway):
return _make_eris_incore(self, mo_coeff, verbose=self.verbose)
elif getattr(self._scf, 'with_df', None):
raise NotImplementedError
else:
return _make_eris_outcore(self, mo_coeff, self.verbose)
make_rdm1 = make_rdm1
make_rdm2 = make_rdm2
MP2 = GMP2
from pyscf import scf
scf.ghf.GHF.MP2 = lib.class_as_method(MP2)
class _PhysicistsERIs:
def __init__(self, mp, mo_coeff=None):
self.orbspin = None
if mo_coeff is None:
mo_coeff = mp.mo_coeff
mo_idx = mp.get_frozen_mask()
if getattr(mo_coeff, 'orbspin', None) is not None:
self.orbspin = mo_coeff.orbspin[mo_idx]
mo_coeff = lib.tag_array(mo_coeff[:,mo_idx], orbspin=self.orbspin)
self.mo_coeff = mo_coeff
else:
orbspin = scf.ghf.guess_orbspin(mo_coeff)
if nmo is None: nmo = self.nmo
if nocc is None: nocc = self.nocc
return cisdvec_to_amplitudes(civec, nmo, nocc)
make_rdm1 = make_rdm1
make_rdm2 = make_rdm2
trans_rdm1 = trans_rdm1
def nuc_grad_method(self):
from pyscf.grad import ucisd
return ucisd.Gradients(self)
CISD = UCISD
from pyscf import scf
scf.uhf.UHF.CISD = lib.class_as_method(CISD)
def _cp(a):
return numpy.array(a, copy=False, order='C')
if __name__ == '__main__':
from pyscf import gto
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)],
logger.timer(self, 'Rotational g-tensors', *cput0)
if self.verbose >= logger.NOTE:
_write = rhf_nmr._write
_write(self.stdout, e2, '\nRotational g-tensors (au)')
#FIXME: Dia-, para-magnetic parts are partitioned in different way
#See JCP, 105, 2804
#_write(self.stdout, mag_dia, 'dia-magnetic contributions (au)')
#_write(self.stdout, mag_para, 'para-magnetic contributions (au)')
_write(self.stdout, e_nuc, 'nuclear contributions (au)')
return e2
dia = dia
para = para
from pyscf import scf
scf.hf.RHF.RotationalGTensor = lib.class_as_method(RotationalGTensor)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. .917
F , 0. 0. 0.
'''
mol.basis = 'ccpvdz'
mol.build()
mf = scf.RHF(mol).run()
def get_ab(self, mf=None):
raise NotImplementedError
def nuc_grad_method(self):
raise NotImplementedError
CIS = TDA
class TDHF(uhf.TDHF):
def gen_vind(self, mf):
vind, hdiag = uhf.TDHF.gen_vind(self, mf)
def vindp(x):
with lib.temporary_env(mf, exxdiv=None):
return vind(x)
return vindp, hdiag
def get_ab(self, mf=None):
raise NotImplementedError
def nuc_grad_method(self):
raise NotImplementedError
RPA = TDUHF = TDHF
from pyscf.pbc import scf
scf.uhf.UHF.TDA = lib.class_as_method(TDA)
scf.uhf.UHF.TDHF = lib.class_as_method(TDHF)
def density_fit(self, auxbasis=None, with_df=None):
from pyscf.mcscf import df
return df.density_fit(self, auxbasis, with_df)
def sfx2c1e(self):
from pyscf.x2c import sfx2c1e
self._scf = sfx2c1e.sfx2c1e(self._scf)
return self
x2c = x2c1e = sfx2c1e
def nuc_grad_method(self):
from pyscf.grad import casci
return casci.Gradients(self)
scf.hf.RHF.CASCI = scf.rohf.ROHF.CASCI = lib.class_as_method(CASCI)
scf.uhf.UHF.CASCI = None
del(WITH_META_LOWDIN, LARGE_CI_TOL, PENALTY)
if __name__ == '__main__':
from pyscf import mcscf
mol = gto.Mole()
mol.verbose = 0
mol.output = None#"out_h2o"
mol.atom = [
['O', ( 0., 0. , 0. )],
['H', ( 0., -0.757, 0.587)],
['H', ( 0., 0.757 , 0.587)],]
def density_fit(self, auxbasis=None, with_df=None):
from pyscf.mcscf import df
return df.density_fit(self, auxbasis, with_df)
def sfx2c1e(self):
from pyscf.x2c import sfx2c1e
self._scf = sfx2c1e.sfx2c1e(self._scf)
return self
x2c = x2c1e = sfx2c1e
def nuc_grad_method(self):
from pyscf.grad import casci
return casci.Gradients(self)
scf.hf.RHF.CASCI = scf.rohf.ROHF.CASCI = lib.class_as_method(CASCI)
scf.uhf.UHF.CASCI = None
del (WITH_META_LOWDIN, LARGE_CI_TOL, PENALTY)
if __name__ == '__main__':
from pyscf import mcscf
mol = gto.Mole()
mol.verbose = 0
mol.output = None #"out_h2o"
mol.atom = [
['O', (0., 0., 0.)],
['H', (0., -0.757, 0.587)],
['H', (0., 0.757, 0.587)],
]
def vind(mo1):
dm1 = lib.einsum('xai,pa,qi->xpq', mo1.reshape(-1,nmo,nocc), mo_coeff,
orbo.conj())
dm1 = (dm1 + dm1.transpose(0,2,1).conj()) * 2
v1mo = lib.einsum('xpq,pi,qj->xij', vresp(dm1), mo_coeff.conj(), orbo)
return v1mo.ravel()
return vind
polarizability = polarizability
polarizability_with_freq = polarizability_with_freq
hyper_polarizability = hyper_polarizability
from pyscf import scf
scf.hf.RHF.Polarizability = lib.class_as_method(Polarizability)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.atom = '''h , 0. 0. 0.
F , 0. 0. .917'''
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-14)
polar = mf.Polarizability().polarizability()
hpol = mf.Polarizability().hyper_polarizability()
print(polar)
v1a = lib.einsum('xpq,pi,qj->xij', v1ao[0], mo0a.conj(), orboa)
v1b = lib.einsum('xpq,pi,qj->xij', v1ao[1], mo0b.conj(), orbob)
v1mo = numpy.hstack(
(v1a.reshape(-1, nmoa * nocca), v1b.reshape(-1, nmob * noccb)))
return v1mo.ravel()
return vind
polarizability = polarizability
polarizability_with_freq = polarizability_with_freq
hyper_polarizability = hyper_polarizability
from pyscf import scf
scf.uhf.UHF.Polarizability = lib.class_as_method(Polarizability)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
# Disagreement between analytical results and finite difference found for
# linear molecule
#mol.atom = '''h , 0. 0. 0.
# F , 0. 0. .917'''
mol.atom = '''O 0. 0. 0.
H 0. -0.757 0.587
H 0. 0.757 0.587'''
mol.spin = 2
mol.basis = '631g'
def para(self, mol=None, mo10=None, mo_coeff=None, mo_occ=None,
nuc_pair=None):
ssc_para = self.make_pso(mol, mo1, mo_coeff, mo_occ)
if self.with_fcsd:
ssc_para += self.make_fcsd(mol, mo1, mo_coeff, mo_occ)
elif self.with_fc:
ssc_para += self.make_fc(mol, mo1, mo_coeff, mo_occ)
return ssc_para
solve_mo1 = solve_mo1
SSC = SpinSpinCoupling
from pyscf import scf
scf.hf.RHF.SSC = scf.hf.RHF.SpinSpinCoupling = lib.class_as_method(SSC)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom.extend([
[1 , (0. , 0. , .917)],
['F' , (0. , 0. , 0.)], ])
mol.nucmod = {'F': 2} # gaussian nuclear model
mol.basis = {'H': '6-31g',
'F': '6-31g',}
RPA = KTDDFT = TDDFT = krhf.TDHF
#TODO:
TDDFTNoHybrid = TDDFT
def tddft(mf):
'''Driver to create TDDFT or TDDFTNoHybrid object'''
if mf._numint.libxc.is_hybrid_xc(mf.xc):
return TDDFT(mf)
else:
return TDDFTNoHybrid(mf)
from pyscf.pbc import dft
dft.krks.KRKS.TDA = lib.class_as_method(KTDA)
dft.krks.KRKS.TDHF = None
dft.krks.KRKS.TDDFT = tddft
dft.kroks.KROKS.TDA = None
dft.kroks.KROKS.TDHF = None
dft.kroks.KROKS.TDDFT = None
if __name__ == '__main__':
from pyscf.pbc import gto
from pyscf.pbc import dft, df
cell = gto.Cell()
cell.unit = 'B'
cell.atom = '''
C 0. 0. 0.
C 1.68506879 1.68506879 1.68506879
return get_ovlp(mol)
def get_veff(self, mol, dm):
return get_coulomb_hf(mol, dm, level=self.level)
def grad_elec(self, mo_energy=None, mo_coeff=None, mo_occ=None,
atmlst=None):
if mo_energy is None: mo_energy = self.base.mo_energy
if mo_coeff is None: mo_coeff = self.base.mo_coeff
if mo_occ is None: mo_occ = self.base.mo_occ
return grad_elec(self, mo_energy, mo_coeff, mo_occ, atmlst)
Grad = Gradients
from pyscf import scf
scf.dhf.UHF.Gradients = lib.class_as_method(Gradients)
def _call_vhf1_llll(mol, dm):
n2c = dm.shape[0] // 2
dmll = dm[:n2c,:n2c].copy()
vj = numpy.zeros((3,n2c*2,n2c*2), dtype=numpy.complex)
vk = numpy.zeros((3,n2c*2,n2c*2), dtype=numpy.complex)
vj[:,:n2c,:n2c], vk[:,:n2c,:n2c] = \
_vhf.rdirect_mapdm('int2e_ip1_spinor', 's2kl',
('lk->s1ij', 'jk->s1il'), dmll, 3,
mol._atm, mol._bas, mol._env)
return vj, vk
def _call_vhf1(mol, dm):
c1 = .5 / lib.param.LIGHT_SPEED
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------------- %s gradients ---------------',
self.base.__class__.__name__)
rhf_grad._write(self, self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
# Inject to RMP2 class
mp2.MP2.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.M(
atom = [
["O" , (0. , 0. , 0.)],
[1 , (0. ,-0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)]],
basis = '631g'
)
mf = scf.RHF(mol).run()
mp = mp2.MP2(mf).run()
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------------- %s gradients ---------------',
self.base.__class__.__name__)
rhf_grad._write(self, self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
from pyscf import mcscf
mcscf.casci.CASCI.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import mcscf
mol = gto.Mole()
mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
mol.build()
mf = scf.RHF(mol).run(conv_tol=1e-14)
mc = mcscf.CASCI(mf, 4, 4).run()
g1 = mc.Gradients().kernel()
print(lib.finger(g1) - -0.066025991364829367)
return vmata, vmatb
class Hessian(uhf_hess.Hessian):
'''Non-relativistic UKS hessian'''
def __init__(self, mf):
uhf_hess.Hessian.__init__(self, mf)
self.grids = None
self.grid_response = False
self._keys = self._keys.union(['grids'])
partial_hess_elec = partial_hess_elec
make_h1 = make_h1
from pyscf import dft
dft.uks.UKS.Hessian = dft.uks_symm.UKS.Hessian = lib.class_as_method(Hessian)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
#xc_code = 'lda,vwn'
xc_code = 'wb97x'
#xc_code = 'b3lyp'
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
[1 , (1. , 0. , 0.000)],
class Hessian(rhf_hess.Hessian):
'''Non-relativistic UHF hessian'''
partial_hess_elec = partial_hess_elec
hess_elec = hess_elec
make_h1 = make_h1
gen_hop = gen_hop
def solve_mo1(self, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
fx=None, atmlst=None, max_memory=4000, verbose=None):
return solve_mo1(self.base, mo_energy, mo_coeff, mo_occ, h1ao_or_chkfile,
fx, atmlst, max_memory, verbose)
from pyscf import scf
scf.uhf.UHF.Hessian = lib.class_as_method(Hessian)
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.unit = 'B'
self._finalize()
return self.de
# Calling the underlying SCF nuclear gradients because it may be modified
# by external modules (e.g. QM/MM, solvent)
def grad_nuc(self, mol=None, atmlst=None):
mf_grad = self.base._scf.nuc_grad_method()
return mf_grad.grad_nuc(mol, atmlst)
as_scanner = as_scanner
Grad = Gradients
# Inject to RMP2 class
mp2.MP2.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.M(atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]],
basis='631g')
mf = scf.RHF(mol).run()
mp = mp2.MP2(mf).run()
g1 = Gradients(mp).kernel()
# O -0.0000000000 -0.0000000000 0.0089211366
# H 0.0000000000 0.0222745046 -0.0044605683
# H 0.0000000000 -0.0222745046 -0.0044605683
print(lib.finger(g1) - -0.035681171529705444)
for eri1 in with_df.loop(blksize=blksize):
Lov = _ao2mo.nr_e2(eri1, mo, ijslice, aosym='s2', out=Lov)
yield Lov
# def make_rdm1(self, t2=None, ao_repr=False):
# if t2 is None: t2 = self.t2
# return make_rdm1(self, t2, self.verbose)
#
# def make_rdm2(self, t2=None):
# if t2 is None: t2 = self.t2
# return make_rdm2(self, t2, self.verbose)
MP2 = DFMP2
from pyscf import scf
scf.hf.RHF.DFMP2 = lib.class_as_method(DFMP2)
scf.rohf.ROHF.DFMP2 = None
scf.uhf.UHF.DFMP2 = None
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)]]
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spatial2spin(tx, orbspin)
def spin2spatial(self, tx, orbspin=None):
if orbspin is None:
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spin2spatial(tx, orbspin)
CISD = GCISD
from pyscf import scf
scf.ghf.GHF.CISD = lib.class_as_method(CISD)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import ao2mo
from pyscf.cc.addons import spatial2spin
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',
Non-relativistic nuclear spin-rotation tensors for RKS
'''
from pyscf.prop.nmr import rks as rks_nmr
from pyscf.prop.nsr import rhf as rhf_nsr
class NSR(rhf_nsr.NSR):
'''Nuclear-spin rotation tensors for RKS'''
get_fock = rks_nmr.get_fock
solve_mo1 = rks_nmr.solve_mo1
from pyscf import lib
from pyscf import dft
dft.rks.RKS.NSR = dft.rks_symm.RKS.NSR = lib.class_as_method(NSR)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
from pyscf import lib
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. 0.917
f , 0. 0. 0.
'''
mol.basis = 'dzp'
mol.build()
mo_coeff=None,
mo_occ=None,
nuc_pair=None):
ssc_para = self.make_pso(mol, mo1, mo_coeff, mo_occ)
if self.with_fcsd:
ssc_para += self.make_fcsd(mol, mo1, mo_coeff, mo_occ)
elif self.with_fc:
ssc_para += self.make_fc(mol, mo1, mo_coeff, mo_occ)
return ssc_para
solve_mo1 = solve_mo1
SSC = SpinSpinCoupling
from pyscf import scf
scf.hf.RHF.SSC = scf.hf.RHF.SpinSpinCoupling = lib.class_as_method(SSC)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom.extend([
[1, (0., 0., .917)],
['F', (0., 0., 0.)],
])
mol.nucmod = {'F': 2} # gaussian nuclear model
mol.basis = {
'H': '6-31g',
return vmat
class Hessian(rhf_hess.Hessian):
'''Non-relativistic RKS hessian'''
def __init__(self, mf):
rhf_hess.Hessian.__init__(self, mf)
self.grids = None
self._keys = self._keys.union(['grids'])
partial_hess_elec = partial_hess_elec
make_h1 = make_h1
from pyscf import dft
dft.rks.RKS.Hessian = dft.rks_symm.RKS.Hessian = lib.class_as_method(Hessian)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
#dft.numint.NumInt.libxc = dft.xcfun
#xc_code = 'lda,vwn'
xc_code = 'wb97x'
#xc_code = 'b3lyp'
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
[1 , (1. , 0. , 0.000)],
[1 , (0. , 1. , 0.000)],
'''
if self.grid_response:
vhf = envs['vhf']
log = envs['log']
log.debug('grids response for atom %d %s', atom_id,
vhf.exc1_grid[atom_id])
return vhf.exc1_grid[atom_id]
else:
return 0
Grad = Gradients
from pyscf import dft
dft.uks.UKS.Gradients = dft.uks_symm.UKS.Gradients = lib.class_as_method(
Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.atom = [['O', (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]]
mol.basis = '631g'
mol.charge = 1
mol.spin = 1
mol.build()
mf = dft.UKS(mol)
mf.conv_tol = 1e-12
#mf.grids.atom_grid = (20,86)
_write(self.stdout, e11[i],
'\ntotal NSR of atom %d %s' \
% (atm_id, self.mol.atom_symbol(atm_id)))
_write(self.stdout, e11[i], '\nNuclear spin rotation (kHz)')
_write(self.stdout, e_dia[i],
'dia-magnetic contribution (kHz)')
_write(self.stdout, e_para[i],
'para-magnetic contribution (kHz)')
return e11
dia = dia
para = para
from pyscf import scf
scf.hf.RHF.NSR = lib.class_as_method(NSR)
def _write(stdout, nsr3x3, title):
stdout.write('%s\n' % title)
stdout.write('mu_x %s\n' % str(nsr3x3[0]))
stdout.write('mu_y %s\n' % str(nsr3x3[1]))
stdout.write('mu_z %s\n' % str(nsr3x3[2]))
stdout.flush()
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 7
self.de = self.symmetrize(self.de, atmlst)
self._finalize()
return self.de
# Calling the underlying SCF nuclear gradients because it may be modified
# by external modules (e.g. QM/MM, solvent)
def grad_nuc(self, mol=None, atmlst=None):
mf_grad = self.base._scf.nuc_grad_method()
return mf_grad.grad_nuc(mol, atmlst)
as_scanner = as_scanner
Grad = Gradients
ccsd.CCSD.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.M(atom=[["O", (0., 0., 0.)], [1, (0., -0.757, 0.587)],
[1, (0., 0.757, 0.587)]],
basis='631g')
mf = scf.RHF(mol).run()
mycc = ccsd.CCSD(mf).run()
g1 = mycc.Gradients().kernel()
#[[ 0 0 1.00950925e-02]
# [ 0 2.28063426e-02 -5.04754623e-03]
# [ 0 -2.28063426e-02 -5.04754623e-03]]
print(lib.finger(g1) - -0.036999389889460096)
if s2 > 1e-4:
logger.warn(
self,
'<S^2> = %s. UHF-NMR shielding may have large error.\n'
'paramagnetic NMR should include this result plus '
'g-tensor and HFC tensors.', s2)
return rhf_nmr.NMR.shielding(self, mo1)
dia = dia
para = para
get_fock = get_fock
solve_mo1 = solve_mo1
from pyscf import scf
scf.uhf.UHF.NMR = lib.class_as_method(NMR)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom.extend([
[1, (0., 0., .917)],
['F', (0., 0., 0.)],
])
mol.nucmod = {'F': 2} # gaussian nuclear model
mol.basis = {
'H': '6-31g',
# For non-canonical MP2
energy = energy
update_amps = update_amps
def init_amps(self,
mo_energy=None,
mo_coeff=None,
eris=None,
with_t2=WITH_T2):
return kernel(self, mo_energy, mo_coeff, eris, with_t2)
MP2 = GMP2
from pyscf import scf
scf.ghf.GHF.MP2 = lib.class_as_method(MP2)
#TODO: Merge this _PhysicistsERIs class with gccsd._PhysicistsERIs class
class _PhysicistsERIs:
def __init__(self, mol=None):
self.mol = mol
self.mo_coeff = None
self.nocc = None
self.fock = None
self.e_hf = None
self.orbspin = None
self.oovv = None
def _common_init_(self, mp, mo_coeff=None):
if mo_coeff is None:
class Hessian(rhf_hess.Hessian):
'''Non-relativistic RKS hessian'''
def __init__(self, mf):
rhf_hess.Hessian.__init__(self, mf)
self.grids = None
self.grid_response = False
self._keys = self._keys.union(['grids'])
partial_hess_elec = partial_hess_elec
make_h1 = make_h1
from pyscf import dft
dft.rks.RKS.Hessian = dft.rks_symm.RKS.Hessian = lib.class_as_method(Hessian)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
#dft.numint.NumInt.libxc = dft.xcfun
#xc_code = 'lda,vwn'
xc_code = 'wb97x'
#xc_code = 'b3lyp'
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
[1, (1., 0., 0.000)],
[1, (0., 1., 0.000)],
return vmata, vmatb
class Hessian(uhf_hess.Hessian):
'''Non-relativistic UKS hessian'''
def __init__(self, mf):
uhf_hess.Hessian.__init__(self, mf)
self.grids = None
self._keys = self._keys.union(['grids'])
partial_hess_elec = partial_hess_elec
make_h1 = make_h1
from pyscf import dft
dft.uks.UKS.Hessian = dft.uks_symm.UKS.Hessian = lib.class_as_method(Hessian)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
#xc_code = 'lda,vwn'
xc_code = 'wb97x'
#xc_code = 'b3lyp'
mol = gto.Mole()
mol.verbose = 0
mol.output = None
mol.atom = [
[1 , (1. , 0. , 0.000)],
self.mo10, self.mo_e10 = self.solve_mo1()
mo10 = self.mo10
return para(mol, mo10, mo_coeff, mo_occ, shielding_nuc)
make_h10 = get_fock = get_fock
def make_s10(self, mol=None, gauge_orig=None):
if mol is None: mol = self.mol
if gauge_orig is None: gauge_orig = self.gauge_orig
return make_s10(mol, gauge_orig, mb=self.mb)
get_ovlp = make_s10
solve_mo1 = solve_mo1
from pyscf import scf
scf.dhf.UHF.NMR = lib.class_as_method(NMR)
def _call_rmb_vhf1(mol, dm, key='giao'):
c1 = .5 / lib.param.LIGHT_SPEED
n2c = dm.shape[0] // 2
dmll = dm[:n2c,:n2c].copy()
dmls = dm[:n2c,n2c:].copy()
dmsl = dm[n2c:,:n2c].copy()
dmss = dm[n2c:,n2c:].copy()
vj = numpy.zeros((3,n2c*2,n2c*2), dtype=numpy.complex)
vk = numpy.zeros((3,n2c*2,n2c*2), dtype=numpy.complex)
vx = _vhf.rdirect_mapdm('int2e_'+key+'_sa10sp1spsp2_spinor', 's2kl',
('ji->s2kl', 'lk->s1ij', 'jk->s1il', 'li->s1kj'),
dmss, 3, mol._atm, mol._bas, mol._env) * c1**4
for i in range(3):
raise RuntimeError
mo_coeff, mo_energy = _add_padding(self, mo_coeff, mo_energy)
# TODO: compute e_hf for non-canonical SCF
self.e_hf = self._scf.e_tot
self.e_corr, self.t2 = \
kernel(self, mo_energy, mo_coeff, verbose=self.verbose, with_t2=with_t2)
logger.log(self, 'KMP2 energy = %.15g', self.e_corr)
return self.e_corr, self.t2
KRMP2 = KMP2
from pyscf.pbc import scf
scf.khf.KRHF.MP2 = lib.class_as_method(KRMP2)
scf.kghf.KGHF.MP2 = None
scf.krohf.KROHF.MP2 = None
if __name__ == '__main__':
from pyscf.pbc import gto, scf, mp
cell = gto.Cell()
cell.atom='''
C 0.000000000000 0.000000000000 0.000000000000
C 1.685068664391 1.685068664391 1.685068664391
'''
cell.basis = 'gth-szv'
cell.pseudo = 'gth-pade'
cell.a = '''
f1vo[:,1:] *= -1
if f1oo is not None: f1oo[:,1:] *= -1
if v1ao is not None: v1ao[:,1:] *= -1
if k1ao is not None: k1ao[:,1:] *= -1
return f1vo, f1oo, v1ao, k1ao
class Gradients(tdrhf_grad.Gradients):
def grad_elec(self, xy, singlet, atmlst=None):
return kernel(self, xy, atmlst, self.max_memory, self.verbose)
Grad = Gradients
from pyscf import tdscf
tdscf.uks.TDA.Gradients = tdscf.uks.TDDFT.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
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'
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spatial2spin(tx, orbspin)
def spin2spatial(self, tx, orbspin=None):
if orbspin is None:
orbspin = getattr(self.mo_coeff, 'orbspin', None)
if orbspin is not None:
orbspin = orbspin[self.get_frozen_mask()]
return spin2spatial(tx, orbspin)
CISD = GCISD
from pyscf import scf
scf.ghf.GHF.CISD = lib.class_as_method(CISD)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import ao2mo
from pyscf.cc.addons import spatial2spin
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',
e2 = rhf_g._safe_solve(im, e2)
return -4 * nist.PROTON_MASS_AU * e2
else:
return uhf_g.dia(magobj, gauge_orig)
class RotationalGTensor(uhf_g.RotationalGTensor):
'''Rotational g-tensors for UKS'''
dia = dia
get_fock = uks_nmr.get_fock
solve_mo1 = uks_nmr.solve_mo1
from pyscf import lib
from pyscf import dft
dft.uks.UKS.RotationalGTensor = dft.uks_symm.UKS.RotationalGTensor = lib.class_as_method(
RotationalGTensor)
if __name__ == '__main__':
from pyscf import lib
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.verbose = 7
mol.output = '/dev/null'
mol.atom = '''h , 0. 0. .917
F , 0. 0. 0.
'''
mol.basis = 'ccpvdz'
mol.build()
mf = dft.UKS(mol).run(xc='b3lyp')
x, y = z.reshape(2, nocc, nvir)
norm = lib.norm(x)**2 - lib.norm(y)**2
norm = numpy.sqrt(.5 / norm) # normalize to 0.5 for alpha spin
return x * norm, y * norm
self.xy = [norm_xy(z) for z in x1]
if self.chkfile:
lib.chkfile.save(self.chkfile, 'tddft/e', self.e)
lib.chkfile.save(self.chkfile, 'tddft/xy', self.xy)
log.timer('TDDFT', *cpu0)
self._finalize()
return self.e, self.xy
def nuc_grad_method(self):
from pyscf.grad import tdrhf
return tdrhf.Gradients(self)
RPA = TDRHF = TDHF
scf.hf.RHF.TDA = lib.class_as_method(TDA)
scf.hf.RHF.TDHF = lib.class_as_method(TDHF)
scf.rohf.ROHF.TDA = None
scf.rohf.ROHF.TDHF = None
scf.hf_symm.ROHF.TDA = None
scf.hf_symm.ROHF.TDHF = None
del (OUTPUT_THRESHOLD)
from pyscf import lib
from pyscf.scf import addons
from pyscf.grad import uks as uks_grad
class Gradients(uks_grad.Gradients):
'''Non-relativistic ROHF gradients
'''
def __init__(self, mf):
uks_grad.Gradients.__init__(self, addons.convert_to_uhf(mf))
Grad = Gradients
from pyscf import dft
dft.roks.ROKS.Gradients = dft.rks_symm.ROKS.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import dft
mol = gto.Mole()
mol.atom = [
['O' , (0. , 0. , 0.)],
[1 , (0. , -0.757 , 0.587)],
[1 , (0. , 0.757 , 0.587)] ]
mol.basis = '631g'
mol.charge = 1
mol.spin = 1
mol.build()
mf = dft.ROKS(mol)
if with_df is not None:
mymp.with_df = with_df
if mymp.with_df.auxbasis != auxbasis:
mymp.with_df = copy.copy(mymp.with_df)
mymp.with_df.auxbasis = auxbasis
return mymp
def nuc_grad_method(self):
from pyscf.grad import mp2
return mp2.Gradients(self)
RMP2 = MP2
from pyscf import scf
scf.hf.RHF.MP2 = lib.class_as_method(MP2)
scf.rohf.ROHF.MP2 = None
def _mo_energy_without_core(mp, mo_energy):
return mo_energy[get_frozen_mask(mp)]
def _mo_without_core(mp, mo):
return mo[:, get_frozen_mask(mp)]
def _mem_usage(nocc, nvir):
nmo = nocc + nvir
basic = ((nocc * nvir)**2 + nocc * nvir**2 * 2) * 8 / 1e6
incore = nocc * nvir * nmo**2 / 2 * 8 / 1e6 + basic
self._finalize()
return self.de
def _finalize(self):
if self.verbose >= logger.NOTE:
logger.note(self, '--------------- %s gradients ---------------',
self.base.__class__.__name__)
rhf_grad._write(self, self.mol, self.de, self.atmlst)
logger.note(self, '----------------------------------------------')
as_scanner = as_scanner
Grad = Gradients
from pyscf import mcscf
mcscf.mc1step.CASSCF.Gradients = lib.class_as_method(Gradients)
if __name__ == '__main__':
from pyscf import gto
from pyscf import scf
from pyscf import mcscf
mol = gto.Mole()
mol.atom = 'N 0 0 0; N 0 0 1.2; H 1 1 0; H 1 1 1.2'
mol.basis = '631g'
mol.build()
mf = scf.RHF(mol).run()
mc = mcscf.CASSCF(mf, 4, 4).run()
de = mc.Gradients().kernel()
print(lib.finger(de) - 0.019602220578635747)
