def DMRGSCF(mf, norb, nelec, maxM=1000, tol=1.e-8, *args, **kwargs):
'''Shortcut function to setup CASSCF using the DMRG solver. The DMRG
solver is properly initialized in this function so that the 1-step
algorithm can be applied with DMRG-CASSCF.
Examples:
>>> mol = gto.M(atom='C 0 0 0; C 0 0 1')
>>> mf = scf.RHF(mol).run()
>>> mc = DMRGSCF(mf, 4, 4)
>>> mc.kernel()
-74.414908818611522
'''
if getattr(mf, 'with_df', None):
mc = mcscf.DFCASSCF(mf, norb, nelec, *args, **kwargs)
else:
mc = mcscf.CASSCF(mf, norb, nelec, *args, **kwargs)
mc.fcisolver = DMRGCI(mf.mol, maxM, tol=tol)
mc.callback = mc.fcisolver.restart_scheduler_()
if mc.chkfile == mc._scf._chkfile.name:
# Do not delete chkfile after mcscf
mc.chkfile = tempfile.mktemp(dir=settings.BLOCKSCRATCHDIR)
if not os.path.exists(settings.BLOCKSCRATCHDIR):
os.makedirs(settings.BLOCKSCRATCHDIR)
return mc
def test_assign_cderi(self):
nao = molsym.nao_nr()
w, u = scipy.linalg.eigh(mol.intor('int2e_sph', aosym='s4'))
idx = w > 1e-9
mf = scf.density_fit(scf.RHF(molsym))
mf._cderi = (u[:, idx] * numpy.sqrt(w[idx])).T.copy()
mf.kernel()
mc = mcscf.DFCASSCF(mf, 6, 6)
mc.kernel()
self.assertAlmostEqual(mc.e_tot, -108.98010545803884, 7)
def test_df_ao2mo(self):
mf = scf.density_fit(msym)
mf.max_memory = 100
mf.kernel()
mc = mcscf.DFCASSCF(mf, 4, 4)
with df.load(mf._cderi) as feri:
cderi = numpy.asarray(feri)
eri0 = numpy.dot(cderi.T, cderi)
nmo = mc.mo_coeff.shape[1]
ncore = mc.ncore
nocc = ncore + mc.ncas
eri0 = ao2mo.restore(1, ao2mo.kernel(eri0, mc.mo_coeff), nmo)
eris = mc.ao2mo(mc.mo_coeff)
self.assertTrue(numpy.allclose(eri0[:,:,ncore:nocc,ncore:nocc], eris.ppaa))
self.assertTrue(numpy.allclose(eri0[:,ncore:nocc,:,ncore:nocc], eris.papa))
def test_init(self):
from pyscf.mcscf import df
mf = scf.RHF(mol)
self.assertTrue(isinstance(mcscf.CASCI(mf, 2, 2), mcscf.casci.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(mf.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASCI(mf.newton(), 2, 2), mcscf.casci.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(mf.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASCI(mf.newton().density_fit(), 2, 2), mcscf.casci.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(mf.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf, 2, 2), mcscf.mc1step.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf.newton(), 2, 2), mcscf.mc1step.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf.newton().density_fit(), 2, 2), mcscf.mc1step.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(mf.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf, 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf.newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf.newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASCI(mf.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf, 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf.newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf.newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.DFCASSCF(mf.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASCI(msym, 2, 2), mcscf.casci_symm.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(msym.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASCI(msym.newton(), 2, 2), mcscf.casci_symm.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(msym.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASCI(msym.newton().density_fit(), 2, 2), mcscf.casci_symm.CASCI))
self.assertTrue(isinstance(mcscf.CASCI(msym.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym, 2, 2), mcscf.mc1step_symm.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym.density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym.newton(), 2, 2), mcscf.mc1step_symm.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym.density_fit().newton(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym.newton().density_fit(), 2, 2), mcscf.mc1step_symm.CASSCF))
self.assertTrue(isinstance(mcscf.CASSCF(msym.density_fit().newton().density_fit(), 2, 2), df._DFCASSCF))
self.assertTrue(isinstance(msym.CASCI(2, 2), mcscf.casci_symm.CASCI))
self.assertTrue(isinstance(msym.density_fit().CASCI(2, 2), df._DFCASCI))
self.assertTrue(isinstance(msym.density_fit().CASCI(2, 2), mcscf.casci_symm.CASCI))
self.assertTrue(isinstance(msym.CASSCF(2, 2), mcscf.mc1step_symm.CASSCF))
self.assertTrue(isinstance(msym.density_fit().CASSCF(2, 2), df._DFCASSCF))
self.assertTrue(isinstance(msym.density_fit().CASSCF(2, 2), mcscf.mc1step_symm.CASSCF))
'''
mol = gto.M(atom='H 0 0 0; F 0 0 1', basis='ccpvdz')
#
# Integrals in memory. The size of the integral array is (M,N*(N+1)/2), where
# the last two AO indices are compressed due to the symmetry
#
int3c = df.incore.cholesky_eri(mol, auxbasis='ccpvdz-fit')
mf = scf.density_fit(scf.RHF(mol))
mf.with_df._cderi = int3c
mf.kernel()
# 3-cetner DF or Cholesky decomposed integrals need to be initialized once in
# mf.with_df._cderi. DFCASSCF method automatically use the approximate integrals
mc = mcscf.DFCASSCF(mf, 8, 8)
mc.kernel()
#
# Integrals on disk
#
ftmp = tempfile.NamedTemporaryFile()
df.outcore.cholesky_eri(mol, ftmp.name, auxbasis='ccpvdz-fit')
with h5py.File(ftmp.name, 'r') as file1:
mf = scf.density_fit(scf.RHF(mol))
# Note, here the integral object file1['eri_mo'] are not loaded in memory.
# It is still the HDF5 array object held on disk. The HDF5 array can be used
# the same way as the regular numpy ndarray stored in memory.
mf.with_df._cderi = file1['eri_mo']
pass
elif (itype >= 3 and itype <= 10):
ncore += 1
elif (itype >= 11 and itype <= 18):
ncore += 2
elif (itype >= 19 and itype <= 36):
ncore += 6
aolst1 = ['N 2s']
aolst2 = ['N 2p']
aolst3 = ['N 3s']
aolst4 = ['N 3p']
aolst = aolst1 + aolst2 + aolst3 + aolst4
ncas, nelecas, mo = avas.kernel(mf, aolst, threshold_occ=0.1, threshold_vir=0.01, minao='minao', ncore=ncore)
mc = mcscf.DFCASSCF(mf, ncas, nelecas)
#mc = mcscf.DFCASSCF(mf, ncas, nelecas, auxbasis='aug-cc-pvdz-jkfit')
mc.max_cycle_macro = 250
mc.max_cycle_micro = 7
mc.chkfile = name+'.chk'
mc.fcisolver = fci.direct_spin0_symm.FCI()
mc.fix_spin_(shift=.5, ss=0)
#mc.__dict__.update(scf.chkfile.load(name+'.chk', 'mcscf'))
#mo = lib.chkfile.load(name+'.chk', 'mcscf/mo_coeff')
mc.kernel(mo)
nmo = mc.ncore + mc.ncas
rdm1, rdm2 = mc.fcisolver.make_rdm12(mc.ci, mc.ncas, mc.nelecas)
rdm1, rdm2 = mcscf.addons._make_rdm12_on_mo(rdm1, rdm2, mc.ncore, mc.ncas, nmo)
den_file = name + '.den'
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)
mf.kernel()
#mc = density_fit(mcscf.CASSCF(mf, 6, 4))
#mc = mcscf.CASSCF(mf, 6, 4)
mc = mcscf.DFCASSCF(mf, 6, 4)
mc.verbose = 4
mo = addons.sort_mo(mc, mc.mo_coeff, (3, 4, 6, 7, 8, 9), 1)
emc = mc.kernel(mo)[0]
print(emc, 'ref = -76.0917567904955', emc - -76.0917567904955)
mc.with_dep4 = True
mc.max_cycle_micro = 10
emc = mc.kernel(mo)[0]
print(emc, 'ref = -76.0917567904955', emc - -76.0917567904955)
#mc = density_fit(mcscf.CASCI(mf, 6, 4))
#mc = mcscf.CASCI(mf, 6, 4)
mc = mcscf.DFCASCI(mf, 6, 4)
mo = addons.sort_mo(mc, mc.mo_coeff, (3, 4, 6, 7, 8, 9), 1)
emc = mc.kernel(mo)[0]
print(emc, 'ref = -76.0476686258461', emc - -76.0476686258461)
def CASSCF(self, ncas, nelecas, auxbasis=None, ncore=None, frozen=None):
from pyscf import mcscf
return mcscf.DFCASSCF(self, ncas, nelecas, auxbasis, ncore, frozen)
["C", (-1.35568919, 1.81920887, -0.00868348)],
["H", (-1.20806619, -0.34108413, -0.00755148)],
["H", (1.28636081, -0.34128013, -0.00668648)],
["H", (2.53407081, 1.81906387, -0.00736748)],
["H", (1.28693681, 3.97963587, -0.00925948)],
["H", (-1.20821019, 3.97969587, -0.01063248)],
["H", (-2.45529319, 1.81939187, -0.00886348)],
],
basis='ccpvtz')
mf = scf.RHF(mol)
mf.conv_tol = 1e-8
e = mf.kernel()
#
# DFCASSCF uses density-fitting 2e integrals overall, regardless the
# underlying mean-filed object
#
mc = mcscf.DFCASSCF(mf, 6, 6)
mo = mc.sort_mo([17, 20, 21, 22, 23, 30])
mc.kernel(mo)
print('E(CAS) = %.12f, ref = -230.845892901370' % mc.e_tot)
#
# Assign DF basis
#
mc = mcscf.DFCASSCF(mf, 6, 6, auxbasis='ccpvtzfit')
mo = mc.sort_mo([17, 20, 21, 22, 23, 30])
mc.kernel(mo)
print('E(CAS) = %.12f, ref = -230.845892901370' % mc.e_tot)
def solve (frag, guess_1RDM, chempot_imp):
# Augment OEI with the chemical potential
OEI = frag.impham_OEI_C - chempot_imp
# Do I need to get the full RHF solution?
guess_orbs_av = len (frag.imp_cache) == 2 or frag.norbs_as > 0
# Get the RHF solution
mol = gto.Mole()
abs_2MS = int (round (2 * abs (frag.target_MS)))
abs_2S = int (round (2 * abs (frag.target_S)))
sign_MS = int (np.sign (frag.target_MS)) or 1
mol.spin = abs_2MS
mol.verbose = 0
if frag.mol_stdout is None:
mol.output = frag.mol_output
mol.verbose = 0 if frag.mol_output is None else lib.logger.DEBUG
mol.atom.append(('H', (0, 0, 0)))
mol.nelectron = frag.nelec_imp
if frag.enforce_symmetry:
mol.groupname = frag.symmetry
mol.symm_orb = get_subspace_symmetry_blocks (frag.loc2imp, frag.loc2symm)
mol.irrep_name = frag.ir_names
mol.irrep_id = frag.ir_ids
mol.max_memory = frag.ints.max_memory
mol.build ()
if frag.mol_stdout is None:
frag.mol_stdout = mol.stdout
else:
mol.stdout = frag.mol_stdout
mol.verbose = 0 if frag.mol_output is None else lib.logger.DEBUG
if frag.enforce_symmetry: mol.symmetry = True
#mol.incore_anyway = True
mf = scf.RHF(mol)
mf.get_hcore = lambda *args: OEI
mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp)
mf.energy_nuc = lambda *args: frag.impham_CONST
if frag.impham_CDERI is not None:
mf = mf.density_fit ()
mf.with_df._cderi = frag.impham_CDERI
else:
mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp)
mf = fix_my_RHF_for_nonsinglet_env (mf, frag.impham_OEI_S)
mf.__dict__.update (frag.mf_attr)
if guess_orbs_av: mf.max_cycle = 2
mf.scf (guess_1RDM)
if (not mf.converged) and (not guess_orbs_av):
if np.any (np.abs (frag.impham_OEI_S) > 1e-8) and mol.spin != 0:
raise NotImplementedError('Gradient and Hessian fixes for nonsinglet environment of Newton-descent ROHF algorithm')
print ("CASSCF RHF-step not converged on fixed-point iteration; initiating newton solver")
mf = mf.newton ()
mf.kernel ()
# Instability check and repeat
if not guess_orbs_av:
for i in range (frag.num_mf_stab_checks):
if np.any (np.abs (frag.impham_OEI_S) > 1e-8) and mol.spin != 0:
raise NotImplementedError('ROHF stability-check fixes for nonsinglet environment')
mf.mo_coeff = mf.stability ()[0]
guess_1RDM = mf.make_rdm1 ()
mf = scf.RHF(mol)
mf.get_hcore = lambda *args: OEI
mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp)
mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp)
mf = fix_my_RHF_for_nonsinglet_env (mf, frag.impham_OEI_S)
mf.scf (guess_1RDM)
if not mf.converged:
mf = mf.newton ()
mf.kernel ()
E_RHF = mf.e_tot
print ("CASSCF RHF-step energy: {}".format (E_RHF))
# Get the CASSCF solution
CASe = frag.active_space[0]
CASorb = frag.active_space[1]
checkCAS = (CASe <= frag.nelec_imp) and (CASorb <= frag.norbs_imp)
if (checkCAS == False):
CASe = frag.nelec_imp
CASorb = frag.norbs_imp
if (abs_2MS > abs_2S):
CASe = ((CASe + sign_MS * abs_2S) // 2, (CASe - sign_MS * abs_2S) // 2)
else:
CASe = ((CASe + sign_MS * abs_2MS) // 2, (CASe - sign_MS * abs_2MS) // 2)
if frag.impham_CDERI is not None:
mc = mcscf.DFCASSCF(mf, CASorb, CASe)
else:
mc = mcscf.CASSCF(mf, CASorb, CASe)
smult = abs_2S + 1 if frag.target_S is not None else (frag.nelec_imp % 2) + 1
mc.fcisolver = csf_solver (mf.mol, smult, symm=frag.enforce_symmetry)
if frag.enforce_symmetry: mc.fcisolver.wfnsym = frag.wfnsym
mc.max_cycle_macro = 50 if frag.imp_maxiter is None else frag.imp_maxiter
mc.conv_tol = min (1e-9, frag.conv_tol_grad**2)
mc.ah_start_tol = mc.conv_tol / 10
mc.ah_conv_tol = mc.conv_tol / 10
mc.__dict__.update (frag.corr_attr)
mc = fix_my_CASSCF_for_nonsinglet_env (mc, frag.impham_OEI_S)
norbs_amo = mc.ncas
norbs_cmo = mc.ncore
norbs_imo = frag.norbs_imp - norbs_amo
nelec_amo = sum (mc.nelecas)
norbs_occ = norbs_amo + norbs_cmo
#mc.natorb = True
# Guess orbitals
ci0 = None
dm_imp = frag.get_oneRDM_imp ()
fock_imp = mf.get_fock (dm=dm_imp)
if len (frag.imp_cache) == 2:
imp2mo, ci0 = frag.imp_cache
print ("Taking molecular orbitals and ci vector from cache")
elif frag.norbs_as > 0:
nelec_imp_guess = int (round (np.trace (frag.oneRDMas_loc)))
norbs_cmo_guess = (frag.nelec_imp - nelec_imp_guess) // 2
print ("Projecting stored amos (frag.loc2amo; spanning {} electrons) onto the impurity basis and filling the remainder with default guess".format (nelec_imp_guess))
imp2mo, my_occ = project_amo_manually (frag.loc2imp, frag.loc2amo, fock_imp, norbs_cmo_guess, dm=frag.oneRDMas_loc)
elif frag.loc2amo_guess is not None:
print ("Projecting stored amos (frag.loc2amo_guess) onto the impurity basis (no amo dm available)")
imp2mo, my_occ = project_amo_manually (frag.loc2imp, frag.loc2amo_guess, fock_imp, norbs_cmo, dm=None)
frag.loc2amo_guess = None
else:
dm_imp = np.asarray (mf.make_rdm1 ())
while dm_imp.ndim > 2:
dm_imp = dm_imp.sum (0)
imp2mo = mf.mo_coeff
fock_imp = mf.get_fock (dm=dm_imp)
fock_mo = represent_operator_in_basis (fock_imp, imp2mo)
_, evecs = matrix_eigen_control_options (fock_mo, sort_vecs=1)
imp2mo = imp2mo @ evecs
my_occ = ((dm_imp @ imp2mo) * imp2mo).sum (0)
print ("No stored amos; using mean-field canonical MOs as initial guess")
# Guess orbital processing
if callable (frag.cas_guess_callback):
mo = reduce (np.dot, (frag.ints.ao2loc, frag.loc2imp, imp2mo))
mo = frag.cas_guess_callback (frag.ints.mol, mc, mo)
imp2mo = reduce (np.dot, (frag.imp2loc, frag.ints.ao2loc.conjugate ().T, frag.ints.ao_ovlp, mo))
frag.cas_guess_callback = None
# Guess CI vector
if len (frag.imp_cache) != 2 and frag.ci_as is not None:
loc2amo_guess = np.dot (frag.loc2imp, imp2mo[:,norbs_cmo:norbs_occ])
metric = np.arange (CASorb) + 1
gOc = np.dot (loc2amo_guess.conjugate ().T, (frag.ci_as_orb * metric[None,:]))
umat_g, svals, umat_c = matrix_svd_control_options (gOc, sort_vecs=1, only_nonzero_vals=True)
if (svals.size == norbs_amo):
print ("Loading ci guess despite shifted impurity orbitals; singular value error sum: {}".format (np.sum (svals - metric)))
imp2mo[:,norbs_cmo:norbs_occ] = np.dot (imp2mo[:,norbs_cmo:norbs_occ], umat_g)
ci0 = transform_ci_for_orbital_rotation (frag.ci_as, CASorb, CASe, umat_c)
else:
print ("Discarding stored ci guess because orbitals are too different (missing {} nonzero svals)".format (norbs_amo-svals.size))
# Symmetry align if possible
imp2unac = frag.align_imporbs_symm (np.append (imp2mo[:,:norbs_cmo], imp2mo[:,norbs_occ:], axis=1), sorting_metric=fock_imp,
sort_vecs=1, orbital_type='guess unactive', mol=mol)[0]
imp2mo[:,:norbs_cmo] = imp2unac[:,:norbs_cmo]
imp2mo[:,norbs_occ:] = imp2unac[:,norbs_cmo:]
#imp2mo[:,:norbs_cmo] = frag.align_imporbs_symm (imp2mo[:,:norbs_cmo], sorting_metric=fock_imp, sort_vecs=1, orbital_type='guess inactive', mol=mol)[0]
imp2mo[:,norbs_cmo:norbs_occ], umat = frag.align_imporbs_symm (imp2mo[:,norbs_cmo:norbs_occ], sorting_metric=fock_imp,
sort_vecs=1, orbital_type='guess active', mol=mol)
#imp2mo[:,norbs_occ:] = frag.align_imporbs_symm (imp2mo[:,norbs_occ:], sorting_metric=fock_imp, sort_vecs=1, orbital_type='guess external', mol=mol)[0]
if frag.enforce_symmetry:
imp2mo = cleanup_subspace_symmetry (imp2mo, mol.symm_orb)
err_symm = measure_subspace_blockbreaking (imp2mo, mol.symm_orb)
err_orth = measure_basis_nonorthonormality (imp2mo)
print ("Initial symmetry error after cleanup = {}".format (err_symm))
print ("Initial orthonormality error after cleanup = {}".format (err_orth))
if ci0 is not None: ci0 = transform_ci_for_orbital_rotation (ci0, CASorb, CASe, umat)
# Guess orbital printing
if frag.mfmo_printed == False and frag.ints.mol.verbose:
ao2mfmo = reduce (np.dot, [frag.ints.ao2loc, frag.loc2imp, imp2mo])
print ("Writing {} {} orbital molden".format (frag.frag_name, 'CAS guess'))
molden.from_mo (frag.ints.mol, frag.filehead + frag.frag_name + '_mfmorb.molden', ao2mfmo, occ=my_occ)
frag.mfmo_printed = True
elif len (frag.active_orb_list) > 0: # This is done AFTER everything else so that the _mfmorb.molden always has consistent ordering
print('Applying caslst: {}'.format (frag.active_orb_list))
imp2mo = mc.sort_mo(frag.active_orb_list, mo_coeff=imp2mo)
frag.active_orb_list = []
if len (frag.frozen_orb_list) > 0:
mc.frozen = copy.copy (frag.frozen_orb_list)
print ("Applying frozen-orbital list (this macroiteration only): {}".format (frag.frozen_orb_list))
frag.frozen_orb_list = []
if frag.enforce_symmetry: imp2mo = lib.tag_array (imp2mo, orbsym=label_orb_symm (mol, mol.irrep_id, mol.symm_orb, imp2mo, s=mf.get_ovlp (), check=False))
t_start = time.time()
E_CASSCF = mc.kernel(imp2mo, ci0)[0]
if (not mc.converged) and np.all (np.abs (frag.impham_OEI_S) < 1e-8):
mc = mc.newton ()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
if not mc.converged:
print ('Assuming ci vector is poisoned; discarding...')
imp2mo = mc.mo_coeff.copy ()
mc = mcscf.CASSCF(mf, CASorb, CASe)
smult = abs_2S + 1 if frag.target_S is not None else (frag.nelec_imp % 2) + 1
mc.fcisolver = csf_solver (mf.mol, smult)
E_CASSCF = mc.kernel(imp2mo)[0]
if not mc.converged:
if np.any (np.abs (frag.impham_OEI_S) > 1e-8):
raise NotImplementedError('Gradient and Hessian fixes for nonsinglet environment of Newton-descent CASSCF algorithm')
mc = mc.newton ()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
assert (mc.converged)
'''
mc.conv_tol = 1e-12
mc.ah_start_tol = 1e-10
mc.ah_conv_tol = 1e-12
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
if not mc.converged:
mc = mc.newton ()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
#assert (mc.converged)
'''
# Get twoRDM + oneRDM. cs: MC-SCF core, as: MC-SCF active space
# I'm going to need to keep some representation of the active-space orbitals
# Symmetry align if possible
oneRDM_amo, twoRDM_amo = mc.fcisolver.make_rdm12 (mc.ci, mc.ncas, mc.nelecas)
fock_imp = mc.get_fock ()
mc.mo_coeff[:,:norbs_cmo] = frag.align_imporbs_symm (mc.mo_coeff[:,:norbs_cmo], sorting_metric=fock_imp, sort_vecs=1, orbital_type='optimized inactive', mol=mol)[0]
mc.mo_coeff[:,norbs_cmo:norbs_occ], umat = frag.align_imporbs_symm (mc.mo_coeff[:,norbs_cmo:norbs_occ],
sorting_metric=oneRDM_amo, sort_vecs=-1, orbital_type='optimized active', mol=mol)
mc.mo_coeff[:,norbs_occ:] = frag.align_imporbs_symm (mc.mo_coeff[:,norbs_occ:], sorting_metric=fock_imp, sort_vecs=1, orbital_type='optimized external', mol=mol)[0]
if frag.enforce_symmetry:
amo2imp = mc.mo_coeff[:,norbs_cmo:norbs_occ].conjugate ().T
mc.mo_coeff = cleanup_subspace_symmetry (mc.mo_coeff, mol.symm_orb)
umat = umat @ (amo2imp @ mc.mo_coeff[:,norbs_cmo:norbs_occ])
err_symm = measure_subspace_blockbreaking (mc.mo_coeff, mol.symm_orb)
err_orth = measure_basis_nonorthonormality (mc.mo_coeff)
print ("Final symmetry error after cleanup = {}".format (err_symm))
print ("Final orthonormality error after cleanup = {}".format (err_orth))
mc.ci = transform_ci_for_orbital_rotation (mc.ci, CASorb, CASe, umat)
# Cache stuff
imp2mo = mc.mo_coeff #mc.cas_natorb()[0]
loc2mo = np.dot (frag.loc2imp, imp2mo)
imp2amo = imp2mo[:,norbs_cmo:norbs_occ]
loc2amo = loc2mo[:,norbs_cmo:norbs_occ]
frag.imp_cache = [mc.mo_coeff, mc.ci]
frag.ci_as = mc.ci
frag.ci_as_orb = loc2amo.copy ()
t_end = time.time()
# oneRDM
oneRDM_imp = mc.make_rdm1 ()
# twoCDM
oneRDM_amo, twoRDM_amo = mc.fcisolver.make_rdm12 (mc.ci, mc.ncas, mc.nelecas)
oneRDMs_amo = np.stack (mc.fcisolver.make_rdm1s (mc.ci, mc.ncas, mc.nelecas), axis=0)
oneSDM_amo = oneRDMs_amo[0] - oneRDMs_amo[1] if frag.target_MS >= 0 else oneRDMs_amo[1] - oneRDMs_amo[0]
oneSDM_imp = represent_operator_in_basis (oneSDM_amo, imp2amo.conjugate ().T)
print ("Norm of spin density: {}".format (linalg.norm (oneSDM_amo)))
# Note that I do _not_ do the *real* cumulant decomposition; I do one assuming oneSDM_amo = 0.
# This is fine as long as I keep it consistent, since it is only in the orbital gradients for this impurity that
# the spin density matters. But it has to stay consistent!
twoCDM_amo = get_2CDM_from_2RDM (twoRDM_amo, oneRDM_amo)
twoCDM_imp = represent_operator_in_basis (twoCDM_amo, imp2amo.conjugate ().T)
print('Impurity CASSCF energy (incl chempot): {}; spin multiplicity: {}; time to solve: {}'.format (E_CASSCF, spin_square (mc)[1], t_end - t_start))
# Active-space RDM data
frag.oneRDMas_loc = symmetrize_tensor (represent_operator_in_basis (oneRDM_amo, loc2amo.conjugate ().T))
frag.oneSDMas_loc = symmetrize_tensor (represent_operator_in_basis (oneSDM_amo, loc2amo.conjugate ().T))
frag.twoCDMimp_amo = twoCDM_amo
frag.loc2mo = loc2mo
frag.loc2amo = loc2amo
frag.E2_cum = np.tensordot (ao2mo.restore (1, mc.get_h2eff (), mc.ncas), twoCDM_amo, axes=4) / 2
frag.E2_cum += (mf.get_k (dm=oneSDM_imp) * oneSDM_imp).sum () / 4
# The second line compensates for my incorrect cumulant decomposition. Anything to avoid changing the checkpoint files...
# General impurity data
frag.oneRDM_loc = frag.oneRDMfroz_loc + symmetrize_tensor (represent_operator_in_basis (oneRDM_imp, frag.imp2loc))
frag.oneSDM_loc = frag.oneSDMfroz_loc + frag.oneSDMas_loc
frag.twoCDM_imp = None # Experiment: this tensor is huge. Do I actually need to keep it? In principle, of course not.
frag.E_imp = E_CASSCF + np.einsum ('ab,ab->', chempot_imp, oneRDM_imp)
return None
norb = ncore + nact
h1e = h1[ncore:norb, ncore:norb].copy()
h1e += 2 * numpy.einsum('Qpq,Qii->pq', eri_mo[:, ncore:norb, ncore:norb],
eri_mo[:, :ncore, :ncore])
h1e -= numpy.einsum('Qpi,Qiq->pq', eri_mo[:, ncore:norb, :ncore],
eri_mo[:, :ncore, ncore:norb])
# Active space two-body integrals
h2e = eri_mo[:, ncore:norb, ncore:norb]
h2e = numpy.einsum('Qpq,Qrs->pqrs', h2e, h2e)
h2e = ao2mo.restore(8, h2e, nact)
e = fci.direct_spin1.kernel(h1e, h2e, nact, nelec, ecore=ecore, verbose=4)[0]
lib.logger.info(mf, 'Core energy: %s' % ecore)
lib.logger.info(mf, 'Total energy: %s' % e)
lib.logger.info(mf, '################')
lib.logger.info(mf, 'Reference values')
lib.logger.info(mf, '################')
mc = mcscf.DFCASSCF(mf, nact, nelec)
h1e_cas, ecore = mc.get_h1eff()
h2e_cas = mc.get_h2eff()
e = fci.direct_spin1.kernel(h1e_cas,
h2e_cas,
nact,
nelec,
ecore=ecore,
verbose=4)[0]
lib.logger.info(mc, 'Core energy: %s' % ecore)
lib.logger.info(mc, 'Total energy: %s' % e)
def test_mc1step_4o4e_df(self):
mc = mcscf.DFCASSCF(m, 4, 4, auxbasis='weigend')
emc = mc.mc1step()[0]
self.assertAlmostEqual(emc, -108.9105231091045, 7)
def solve(frag, guess_1RDM, chempot_imp):
# Augment OEI with the chemical potential
OEI = frag.impham_OEI - chempot_imp
# Do I need to get the full RHF solution?
guess_orbs_av = len(frag.imp_cache) == 2 or frag.norbs_as > 0
# Get the RHF solution
mol = gto.Mole()
mol.spin = int(round(2 * frag.target_MS))
mol.verbose = 0 if frag.mol_output is None else lib.logger.DEBUG
mol.output = frag.mol_output
mol.atom.append(('H', (0, 0, 0)))
mol.nelectron = frag.nelec_imp
mol.build()
#mol.incore_anyway = True
mf = scf.RHF(mol)
mf.get_hcore = lambda *args: OEI
mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp)
mf.energy_nuc = lambda *args: frag.impham_CONST
if frag.impham_CDERI is not None:
mf = mf.density_fit()
mf.with_df._cderi = frag.impham_CDERI
else:
mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp)
mf.__dict__.update(frag.mf_attr)
if guess_orbs_av: mf.max_cycle = 2
mf.scf(guess_1RDM)
if (not mf.converged) and (not guess_orbs_av):
print(
"CASSCF RHF-step not converged on fixed-point iteration; initiating newton solver"
)
mf = mf.newton()
mf.kernel()
# Instability check and repeat
if not guess_orbs_av:
for i in range(frag.num_mf_stab_checks):
mf.mo_coeff = mf.stability()[0]
guess_1RDM = mf.make_rdm1()
mf = scf.RHF(mol)
mf.get_hcore = lambda *args: OEI
mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp)
mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp)
mf.scf(guess_1RDM)
if not mf.converged:
mf = mf.newton()
mf.kernel()
print("CASSCF RHF-step energy: {}".format(mf.e_tot))
#print(mf.mo_occ)
'''
idx = mf.mo_energy.argsort()
mf.mo_energy = mf.mo_energy[idx]
mf.mo_coeff = mf.mo_coeff[:,idx]'''
# Get the CASSCF solution
CASe = frag.active_space[0]
CASorb = frag.active_space[1]
checkCAS = (CASe <= frag.nelec_imp) and (CASorb <= frag.norbs_imp)
if (checkCAS == False):
CASe = frag.nelec_imp
CASorb = frag.norbs_imp
if (frag.target_MS > frag.target_S):
CASe = ((CASe // 2) + frag.target_S, (CASe // 2) - frag.target_S)
else:
CASe = ((CASe // 2) + frag.target_MS, (CASe // 2) - frag.target_MS)
if frag.impham_CDERI is not None:
mc = mcscf.DFCASSCF(mf, CASorb, CASe)
else:
mc = mcscf.CASSCF(mf, CASorb, CASe)
norbs_amo = mc.ncas
norbs_cmo = mc.ncore
norbs_imo = frag.norbs_imp - norbs_amo
nelec_amo = sum(mc.nelecas)
norbs_occ = norbs_amo + norbs_cmo
#mc.natorb = True
# Guess orbitals
ci0 = None
if len(frag.imp_cache) == 2:
imp2mo, ci0 = frag.imp_cache
print("Taking molecular orbitals and ci vector from cache")
elif frag.norbs_as > 0:
nelec_imp_guess = int(round(np.trace(frag.oneRDMas_loc)))
norbs_cmo_guess = (frag.nelec_imp - nelec_imp_guess) // 2
print(
"Projecting stored amos (frag.loc2amo; spanning {} electrons) onto the impurity basis and filling the remainder with default guess"
.format(nelec_imp_guess))
imp2mo, my_occ = project_amo_manually(
frag.loc2imp,
frag.loc2amo,
mf.get_fock(dm=frag.get_oneRDM_imp()),
norbs_cmo_guess,
dm=frag.oneRDMas_loc)
elif frag.loc2amo_guess is not None:
print(
"Projecting stored amos (frag.loc2amo_guess) onto the impurity basis (no dm available)"
)
imp2mo, my_occ = project_amo_manually(
frag.loc2imp,
frag.loc2amo_guess,
mf.get_fock(dm=frag.get_oneRDM_imp()),
norbs_cmo,
dm=None)
frag.loc2amo_guess = None
else:
imp2mo = mc.mo_coeff
my_occ = mf.mo_occ
print(
"No stored amos; using mean-field canonical MOs as initial guess")
# Guess orbital processing
if callable(frag.cas_guess_callback):
mo = reduce(np.dot, (frag.ints.ao2loc, frag.loc2imp, imp2mo))
mo = frag.cas_guess_callback(frag.ints.mol, mc, mo)
imp2mo = reduce(np.dot, (frag.imp2loc, frag.ints.ao2loc.conjugate().T,
frag.ints.ao_ovlp, mo))
frag.cas_guess_callback = None
elif len(frag.active_orb_list) > 0:
print('Applying caslst: {}'.format(frag.active_orb_list))
imp2mo = mc.sort_mo(frag.active_orb_list, mo_coeff=imp2mo)
frag.active_orb_list = []
if len(frag.frozen_orb_list) > 0:
mc.frozen = copy.copy(frag.frozen_orb_list)
print("Applying frozen-orbital list (this macroiteration only): {}".
format(frag.frozen_orb_list))
frag.frozen_orb_list = []
# Guess orbital printing
if frag.mfmo_printed == False:
ao2mfmo = reduce(np.dot, [frag.ints.ao2loc, frag.loc2imp, imp2mo])
molden.from_mo(frag.ints.mol,
frag.filehead + frag.frag_name + '_mfmorb.molden',
ao2mfmo,
occ=my_occ)
frag.mfmo_printed = True
# Guess CI vector
if len(frag.imp_cache) != 2 and frag.ci_as is not None:
loc2amo_guess = np.dot(frag.loc2imp, imp2mo[:, norbs_cmo:norbs_occ])
gOc = np.dot(loc2amo_guess.conjugate().T, frag.ci_as_orb)
umat_g, svals, umat_c = matrix_svd_control_options(
gOc, sort_vecs=-1, only_nonzero_vals=True)
if (svals.size == norbs_amo):
print(
"Loading ci guess despite shifted impurity orbitals; singular value sum: {}"
.format(np.sum(svals)))
imp2mo[:, norbs_cmo:norbs_occ] = np.dot(
imp2mo[:, norbs_cmo:norbs_occ], umat_g)
ci0 = transform_ci_for_orbital_rotation(frag.ci_as, CASorb, CASe,
umat_c)
else:
print(
"Discarding stored ci guess because orbitals are too different (missing {} nonzero svals)"
.format(norbs_amo - svals.size))
t_start = time.time()
smult = 2 * frag.target_S + 1 if frag.target_S is not None else (
frag.nelec_imp % 2) + 1
mc.fcisolver = csf_solver(mf.mol, smult)
mc.max_cycle_macro = 50 if frag.imp_maxiter is None else frag.imp_maxiter
mc.ah_start_tol = 1e-10
mc.ah_conv_tol = 1e-10
mc.conv_tol = 1e-9
mc.__dict__.update(frag.corr_attr)
E_CASSCF = mc.kernel(imp2mo, ci0)[0]
if not mc.converged:
mc = mc.newton()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
if not mc.converged:
print('Assuming ci vector is poisoned; discarding...')
imp2mo = mc.mo_coeff.copy()
mc = mcscf.CASSCF(mf, CASorb, CASe)
smult = 2 * frag.target_S + 1 if frag.target_S is not None else (
frag.nelec_imp % 2) + 1
mc.fcisolver = csf_solver(mf.mol, smult)
E_CASSCF = mc.kernel(imp2mo)[0]
if not mc.converged:
mc = mc.newton()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
assert (mc.converged)
'''
mc.conv_tol = 1e-12
mc.ah_start_tol = 1e-10
mc.ah_conv_tol = 1e-12
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
if not mc.converged:
mc = mc.newton ()
E_CASSCF = mc.kernel(mc.mo_coeff, mc.ci)[0]
#assert (mc.converged)
'''
# Get twoRDM + oneRDM. cs: MC-SCF core, as: MC-SCF active space
# I'm going to need to keep some representation of the active-space orbitals
imp2mo = mc.mo_coeff #mc.cas_natorb()[0]
loc2mo = np.dot(frag.loc2imp, imp2mo)
imp2amo = imp2mo[:, norbs_cmo:norbs_occ]
loc2amo = loc2mo[:, norbs_cmo:norbs_occ]
frag.imp_cache = [mc.mo_coeff, mc.ci]
frag.ci_as = mc.ci
frag.ci_as_orb = loc2amo.copy()
t_end = time.time()
print(
'Impurity CASSCF energy (incl chempot): {}; spin multiplicity: {}; time to solve: {}'
.format(E_CASSCF,
spin_square(mc)[1], t_end - t_start))
# oneRDM
oneRDM_imp = mc.make_rdm1()
# twoCDM
oneRDM_amo, twoRDM_amo = mc.fcisolver.make_rdm12(mc.ci, mc.ncas,
mc.nelecas)
# Note that I do _not_ do the *real* cumulant decomposition; I do one assuming oneRDMs_amo_alpha = oneRDMs_amo_beta
# This is fine as long as I keep it consistent, since it is only in the orbital gradients for this impurity that
# the spin density matters. But it has to stay consistent!
twoCDM_amo = get_2CDM_from_2RDM(twoRDM_amo, oneRDM_amo)
twoCDM_imp = represent_operator_in_basis(twoCDM_amo, imp2amo.conjugate().T)
# General impurity data
frag.oneRDM_loc = symmetrize_tensor(
frag.oneRDMfroz_loc +
represent_operator_in_basis(oneRDM_imp, frag.imp2loc))
frag.twoCDM_imp = None # Experiment: this tensor is huge. Do I actually need to keep it? In principle, of course not.
frag.E_imp = E_CASSCF + np.einsum('ab,ab->', chempot_imp, oneRDM_imp)
# Active-space RDM data
frag.oneRDMas_loc = symmetrize_tensor(
represent_operator_in_basis(oneRDM_amo,
loc2amo.conjugate().T))
frag.twoCDMimp_amo = twoCDM_amo
frag.loc2mo = loc2mo
frag.loc2amo = loc2amo
frag.E2_cum = 0.5 * np.tensordot(
ao2mo.restore(1, mc.get_h2eff(), mc.ncas), twoCDM_amo, axes=4)
return None
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()
nao, nmo = mf.mo_coeff.shape
rdm1, rdm2 = mc.fcisolver.make_rdm12(mc.ci, mc.ncas, mc.nelecas)
rdm1, rdm2 = mcscf.addons._make_rdm12_on_mo(rdm1, rdm2, mc.ncore, mc.ncas, nmo)
naux = mf._cderi.shape[0]
dferi = numpy.empty((naux,nao,nao))
for i in range(naux):
dferi[i] = lib.unpack_tril(mf._cderi[i])
