def get_wm_1RDM_from_OEI(self, OEI, nelec=None, loc2wrk=None): nelec = nelec or self.nelec_idem loc2wrk = loc2wrk if np.any(loc2wrk) else self.loc2idem nocc = nelec // 2 OEI_wrk = represent_operator_in_basis(OEI, loc2wrk) oneRDM_wrk = 2 * get_1RDM_from_OEI(OEI_wrk, nocc) oneRDM_loc = represent_operator_in_basis(oneRDM_wrk, loc2wrk.T) return oneRDM_loc + self.oneRDMcorr_loc
def debug_Etot (dmet_obj): raise NotImplementedError ("Hopelessly broken since last used.") if dmet_obj.CC_E_TYPE == 'CASCI': print ("debug_Etot :: CASCI calculation; passing to debug_Eimp") return debug_Eimp (dmet_obj, dmet_obj.fragments[0]) frags = dmet_obj.fragments for f in frags: debug_Eimp (dmet_obj, f) f.E1_test = 0.0 f.E2_test = 0.0 E0 = dmet_obj.ints.const () E1 = 0.0 E2 = 0.0 print ("debug_Etot :: constant = {0}".format (E0)) for f in itertools.product (frags, frags): fname = "{0} + {1}".format (f[0].frag_name, f[1].frag_name) loc2frag = [i.loc2frag for i in f] OEI_i = [represent_operator_in_basis (dmet_obj.ints.loc_rhf_fock_bis (0.5 * i.oneRDM_loc), *loc2frag) for i in f] oneRDM_i = [0.5 * represent_operator_in_basis (i.oneRDM_loc, *loc2frag) for i in f] E1_i = [np.einsum ('ij,ij->', OEI, oneRDM) for OEI, oneRDM in zip (OEI_i, oneRDM_i)] E1 += sum(E1_i) print ("debug_Etot :: fragments {0} E1 = {1}".format (fname, sum(E1_i))) for E, i in zip (E1_i, f): i.E1_test += E print ("debug_Etot :: one-body = {0}".format (E1)) for f in itertools.product (frags, frags, frags, frags): fname = "{0} + {1} + {2} + {3}".format (f[0].frag_name, f[1].frag_name, f[2].frag_name, f[3].frag_name) loc2frag = [i.loc2frag for i in f] TEI = dmet_obj.ints.general_tei (loc2frag) twoRDM_i = [0.25 * i.get_twoCDM(*loc2frag) for i in f] E2_i = [0.5 * np.einsum ('ijkl,ijkl->', TEI, twoRDM) for twoRDM in twoRDM_i] E2 += sum(E2_i) print ("debug_Etot :: fragments {0} E2 = {1}".format (fname, sum(E2_i))) for E, i in zip (E2_i, f): i.E2_test += E print ("debug_Etot :: two-body = {0}".format (E2)) Etot = E0 + E1 + E2 print ("debug_Etot :: object energy = {0:.5f}, test energy = {1:.5f}, difference = {2:.5f}".format( dmet_obj.energy, Etot, dmet_obj.energy - Etot)) print ("debug_Etot :: fragment energy decomposition:") for f in frags: E_test = f.E1_test + f.E2_test E_diff = f.E_frag - E_test print ("{0} fragment energy = {1:.5f}, test E1 = {2:.5f}, test E2 = {3:.5f}, test Etot = {4:.5f}, difference = {5:.5f}".format( f.frag_name, f.E_frag, f.E1_test, f.E2_test, E_test, E_diff)) del f.E1_test del f.E2_test return Etot
def loc_rhf_jk_bis(self, DMloc): ''' if self._eri is not None: j, k = dot_eri_dm (self._eri, self._eri.loc2eri_op (DMloc), hermi=1) JK_loc = self._eri.eri2loc_op (j - 0.5*k) else: ''' DM_ao = represent_operator_in_basis(DMloc, self.ao2loc.T) JK_ao = self.get_veff_ao(DM_ao, 0, 0, 1) #Last 3 numbers: dm_last, vhf_last, hermi if JK_ao.ndim == 3: JK_ao = JK_ao[0] JK_loc = represent_operator_in_basis(JK_ao, self.ao2loc) return JK_loc
def dmet_const(self, loc2dmet, norbs_imp, oneRDMfroz_loc): norbs_core = self.norbs_tot - norbs_imp if norbs_core == 0: return 0.0 loc2core = loc2dmet[:, norbs_imp:] GAMMA = represent_operator_in_basis(oneRDMfroz_loc, loc2core) OEI = self.dmet_oei(loc2core, norbs_core) FOCK = self.dmet_fock(loc2core, norbs_core, oneRDMfroz_loc) return 0.5 * np.einsum('ij,ij->', GAMMA, OEI + FOCK)
def solve(frag, guess_1RDM, chempot_imp): # Augment OEI with the chemical potential OEI = frag.impham_OEI_C - chempot_imp # 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 4 mol.output = frag.mol_output mol.build() mol.atom.append(('H', (0, 0, 0))) mol.nelectron = frag.nelec_imp #mol.incore_anyway = True #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) h1e = OEI eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) ed = fci.FCI(mol, singlet=(frag.target_S == 0)) if frag.target_S != 0: s2_eval = frag.target_S * (frag.target_S + 1) fix_spin_(ed, ss=s2_eval) # Guess vector ci = None if len(frag.imp_cache) == 1: ci = frag.imp_cache[0] print("Taking initial ci vector from cache") t_start = time.time() ed.conv_tol = 1e-12 E_FCI, ci = ed.kernel(h1e, eri, frag.norbs_imp, frag.nelec_imp, ci0=ci) assert (ed.converged) frag.imp_cache = [ci] t_end = time.time() print( 'Impurity FCI energy (incl chempot): {}; spin multiplicity: {}; time to solve: {}' .format(frag.impham_CONST + E_FCI, ed.spin_square(ci, frag.norbs_imp, frag.nelec_imp)[1], t_end - t_start)) # oneRDM and twoCDM oneRDM_imp, twoRDM_imp = ed.make_rdm12(ci, frag.norbs_imp, frag.nelec_imp) oneRDMs_imp = ed.make_rdm1s(ci, frag.norbs_imp, frag.nelec_imp) twoCDM_imp = get_2CDM_from_2RDM(twoRDM_imp, oneRDMs_imp) # General impurity data frag.oneRDM_loc = symmetrize_tensor( frag.oneRDMfroz_loc + represent_operator_in_basis(oneRDM_imp, frag.imp2loc)) frag.twoCDM_imp = symmetrize_tensor(twoCDM_imp) frag.E_imp = frag.impham_CONST + E_FCI + np.einsum('ab,ab->', chempot_imp, oneRDM_imp) return None
def restore_wm_full_scf(self): self.activeFOCK = represent_operator_in_basis(self.fullFOCKao, self.ao2loc) self.activeJKidem = self.activeFOCK - self.activeOEI self.activeJKcorr = np.zeros((self.norbs_tot, self.norbs_tot), dtype=self.activeOEI.dtype) self.oneRDMcorr_loc = np.zeros((self.norbs_tot, self.norbs_tot), dtype=self.activeOEI.dtype) self.loc2idem = np.eye(self.norbs_tot, dtype=self.activeOEI.dtype) self.nelec_idem = self.nelec_tot
def get_wm_1RDM_from_scf_on_OEI(self, OEI, nelec=None, loc2wrk=None, oneRDMguess_loc=None, output=None): nelec = nelec or self.nelec_idem loc2wrk = loc2wrk if np.any(loc2wrk) else self.loc2idem oneRDM_wrk = represent_operator_in_basis( oneRDMguess_loc, loc2wrk) if np.any(oneRDMguess_loc) else None nocc = nelec // 2 # DON'T call self.get_wm_1RDM_from_OEIidem here because you need to hold oneRDMcorr_loc frozen until the end of the scf! OEI_wrk = represent_operator_in_basis(OEI, loc2wrk) if oneRDM_wrk is None: oneRDM_wrk = 2 * get_1RDM_from_OEI(OEI_wrk, nocc) ''' if self._eri is not None: # I just need a view of self._eri with different tags. ao2loc . loc2wrk = ao2wrk wrk2loc = loc2wrk.conjugate ().T ERI_wrk = self._eri.view () ERI_wrk = tag_array (ERI_wrk, loc2eri_bas = lambda x: self._eri.loc2eri_bas (np.dot (loc2wrk, x))) ERI_wrk = tag_array (ERI_wrk, loc2eri_op = lambda x: self._eri.loc2eri_op (reduce (np.dot, (loc2wrk, x, wrk2loc)))) ERI_wrk = tag_array (ERI_wrk, eri2loc_bas = lambda x: np.dot (wrk2loc, self._eri.eri2loc_bas (x))) ERI_wrk = tag_array (ERI_wrk, eri2loc_op = lambda x: reduce (np.dot, (wrk2loc, self._eri.eri2loc_op (x), loc2wrk))) oneRDM_wrk = wm_rhf.solve_ERI(OEI_wrk, ERI_wrk, oneRDM_wrk, nocc, self.num_mf_stab_checks) else: ''' ao2wrk = np.dot(self.ao2loc, loc2wrk) oneRDM_wrk = wm_rhf.solve_JK(OEI_wrk, ao2wrk, oneRDM_wrk, nocc, self.num_mf_stab_checks, self.get_veff_ao, self.get_jk_ao, output=output) oneRDM_loc = represent_operator_in_basis(oneRDM_wrk, loc2wrk.T) return oneRDM_loc + self.oneRDMcorr_loc
def solve(frag, guess_1RDM, chempot_imp): # Augment OEI with the chemical potential OEI = frag.impham_OEI_C - chempot_imp # Get the RHF solution mol = gto.Mole() mol.build(verbose=0) mol.atom.append(('C', (0, 0, 0))) mol.nelectron = frag.nelec_imp 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._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) mf.scf(guess_1RDM) DMloc = np.dot(np.dot(mf.mo_coeff, np.diag(mf.mo_occ)), mf.mo_coeff.T) if (mf.converged == False): mf = mf.newton() mf.kernel() # Get the MP2 solution mp2 = mp.MP2(mf) mp2.kernel() imp2mo = mf.mo_coeff mo2imp = imp2mo.conjugate().T oneRDMimp_imp = mf.make_rdm1() twoRDMimp_mo = mp2.make_rdm2() twoRDMimp_imp = represent_operator_in_basis(twoRDMimp_mo, mo2imp) twoCDM_imp = get_2CDM_from_2RDM(twoRDMimp_imp, oneRDMimp_imp) # General impurity data frag.oneRDM_loc = symmetrize_tensor( frag.oneRDMfroz_loc + represent_operator_in_basis(oneRDMimp_imp, frag.imp2loc)) frag.twoCDM_imp = symmetrize_tensor(twoCDM_imp) frag.E_imp = frag.impham_CONST + mp2.e_tot + np.einsum( 'ab,ab->', oneRDMimp_imp, chempot_imp) return None
def relocalize_states(self, loc2bas, fragments, oneRDM_loc, natorb=False, canonicalize=False): '''Do Boys localization on a subspace and assign resulting states to the various fragments using projection operators. Optionally diagonalize either the fock or the density matrix inside each subspace. Canonicalize overrides natorb''' fock_loc = self.loc_rhf_fock_bis(oneRDM_loc) ao2bas = boys.Boys(self.mol, np.dot(self.ao2loc, loc2bas)).kernel() loc2bas = reduce(np.dot, [self.ao2loc.conjugate().T, self.ao_ovlp, ao2bas]) weights = np.asarray([ np.einsum('ip,ip->p', loc2bas[f.frag_orb_list, :].conjugate(), loc2bas[f.frag_orb_list, :]) for f in fragments ]) frag_assignments = np.argmax(weights, axis=0) loc2bas_assigned = [] for idx, frag in enumerate(fragments): pick_orbs = (frag_assignments == idx) norbs = np.count_nonzero(pick_orbs) print("{} states found for fragment {}".format( norbs, frag.frag_name)) loc2pick = loc2bas[:, pick_orbs] if canonicalize and norbs: f = represent_operator_in_basis(fock_loc, loc2pick) evals, evecs = matrix_eigen_control_options( f, sort_vecs=1, only_nonzero_vals=False) loc2pick = np.dot(loc2pick, evecs) elif natorb and norbs: f = represent_operator_in_basis(oneRDM_loc, loc2pick) evals, evecs = matrix_eigen_control_options( f, sort_vecs=-1, only_nonzero_vals=False) loc2pick = np.dot(loc2pick, evecs) loc2bas_assigned.append(loc2pick) return loc2bas_assigned
def solve (frag, guess_1RDM, chempot_imp): t_start = time.time () # Augment OEI with the chemical potential OEI = frag.impham_OEI_C - chempot_imp sign_MS = np.sign (frag.target_MS) or 1 # Get the RHF solution mol = gto.Mole() mol.spin = abs (int (round (2 * frag.target_MS))) 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.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 mol.atom.append(('C', (0, 0, 0))) mol.nelectron = frag.nelec_imp 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.quasidirect: mf.get_jk = frag.impham_get_jk else: mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) mf = fix_my_RHF_for_nonsinglet_env (mf, sign_MS * frag.impham_OEI_S) mf.__dict__.update (frag.mf_attr) mf.scf( guess_1RDM ) if ( mf.converged == False ): 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') mf = mf.newton () mf.kernel () # Instability check and repeat 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') new_mo = mf.stability ()[0] guess_1RDM = reduce (np.dot, (new_mo, np.diag (mf.mo_occ), new_mo.conjugate ().T)) mf = scf.RHF( mol ) mf.get_hcore = lambda *args: OEI mf.get_ovlp = lambda *args: np.eye( frag.norbs_imp ) if frag.quasidirect: mf.get_jk = frag.impham_get_jk else: mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) mf = fix_my_RHF_for_nonsinglet_env (mf, sign_MS * frag.impham_OEI_S) mf.scf( guess_1RDM ) if ( mf.converged == False ): mf = mf.newton () mf.kernel () oneRDM_imp = mf.make_rdm1() if np.asarray (oneRDM_imp).ndim == 3: oneSDM_imp = oneRDM_imp[0] - oneRDM_imp[1] oneRDM_imp = oneRDM_imp[0] + oneRDM_imp[1] else: oneSDM_imp = np.zeros_like (oneRDM_imp) print ("Maximum distance between oneRDM_imp and guess_1RDM: {}".format (np.amax (np.abs (oneRDM_imp - guess_1RDM)))) frag.oneRDM_loc = symmetrize_tensor (frag.oneRDMfroz_loc + represent_operator_in_basis (oneRDM_imp, frag.imp2loc)) frag.oneSDM_loc = symmetrize_tensor (frag.oneSDMfroz_loc + represent_operator_in_basis (oneSDM_imp, frag.imp2loc)) frag.twoCDM_imp = None frag.E_imp = mf.e_tot + np.einsum ('ab,ab->', oneRDM_imp, chempot_imp) frag.loc2mo = np.dot (frag.loc2imp, mf.mo_coeff) print ("Time for impurity RHF: {} seconds".format (time.time () - t_start)) return None
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
def compare_basis_to_loc(self, loc2bas, frags, nlead=3, quiet=True): nfrags = len(frags) norbs_tot, norbs_bas = loc2bas.shape if norbs_bas == 0: return np.zeros(nfrags), loc2bas my_dtype = sum([[('weight{0}'.format(i), 'f8'), ('frag{0}'.format(i), 'U3')] for i in range(nfrags)], []) my_dtype += sum([[('coeff{0}'.format(i), 'f8'), ('coord{0}'.format(i), 'U9')] for i in range(nlead)], []) analysis = np.array([ sum(((0, '-') for j in range(len(my_dtype) // 2)), tuple()) for i in range(norbs_bas) ], dtype=my_dtype) bas_weights = np.asarray([ np.diag( represent_operator_in_basis(np.diag(f.is_frag_orb.astype(int)), loc2bas)) for f in frags ]).T bas_frags_idx = np.argsort(bas_weights, axis=1)[:, ::-1] bas_weights = np.sort(bas_weights, axis=1)[:, ::-1] for j in range(nfrags): analysis['weight{0}'.format(j)] = bas_weights[:, j] analysis['frag{0}'.format(j)] = [ frags[i].frag_name for i in bas_frags_idx[:, j] ] def find_frag_fragorb(loc_orbs): thefrag = [ np.where([f.is_frag_orb[i] for f in frags])[0][0] for i in loc_orbs ] thefragorb = [ np.where(frags[i].frag_orb_list == j)[0][0] for i, j in zip(thefrag, loc_orbs) ] thefragname = [frags[i].frag_name for i in thefrag] thestring = [ '{:d}:{:s}'.format(idx, name) for name, idx in zip(thefragname, thefragorb) ] return thestring weights_idx0 = np.argsort(np.absolute(loc2bas), axis=0)[:-nlead - 1:-1, :] weights_idx1 = np.array([range(norbs_bas) for i in range(nlead)]) leading_coeffs = loc2bas[weights_idx0, weights_idx1].T overall_idx = np.argsort(weights_idx0[0, :]) for j in range(nlead): analysis['coeff{0}'.format(j)] = leading_coeffs[:, j] analysis['coord{0}'.format(j)] = find_frag_fragorb( weights_idx0[j, :]) analysis = analysis[overall_idx] if quiet == False: format_str = ' '.join([ '{:' + str(len(name)) + 's}' for name in analysis.dtype.names ]) print(format_str.format(*analysis.dtype.names)) format_str = ' '.join( sum([[ '{:' + str(len(analysis.dtype.names[2 * i])) + '.2f}', '{:>' + str(len(analysis.dtype.names[(2 * i) + 1])) + 's}' ] for i in range(nfrags + nlead)], [])) for i in range(norbs_bas): print(format_str.format(*analysis[i])) print("Worst fragment localization: {:.2f}".format( np.amin(analysis['weight0']))) return loc2bas[:, overall_idx], np.array([ np.count_nonzero(analysis['frag0'] == f.frag_name) for f in frags ])
def __init__(self, the_mf, active_orbs, localizationtype, ao_rotation=None, use_full_hessian=True, localization_threshold=1e-6): assert ((localizationtype == 'meta_lowdin') or (localizationtype == 'boys') or (localizationtype == 'lowdin') or (localizationtype == 'iao')) self.num_mf_stab_checks = 0 # Information on the full HF problem self.mol = the_mf.mol self.max_memory = the_mf.max_memory self.get_jk_ao = partial(the_mf.get_jk, self.mol) self.get_veff_ao = partial(the_mf.get_veff, self.mol) self.fullovlpao = the_mf.get_ovlp self.fullEhf = the_mf.e_tot self.fullDMao = np.dot(np.dot(the_mf.mo_coeff, np.diag(the_mf.mo_occ)), the_mf.mo_coeff.T) self.fullJKao = self.get_veff_ao( dm=self.fullDMao, dm_last=0, vhf_last=0, hermi=1) #Last 3 numbers: dm_last, vhf_last, hermi if self.fullJKao.ndim == 3: self.fullJKao = self.fullJKao[0] # Because I gave it a spin-summed 1-RDM, the two spins for JK will necessarily be identical self.fullFOCKao = the_mf.get_hcore() + self.fullJKao self.oneRDM_loc = np.asarray(the_mf.make_rdm1()) if self.oneRDM_loc.ndim > 2: self.oneRDM_loc = self.oneRDM_loc[0] + self.oneRDM_loc[1] self.e_tot = the_mf.e_tot # Active space information self._which = localizationtype self.active = np.zeros([self.mol.nao_nr()], dtype=int) self.active[active_orbs] = 1 self.norbs_tot = np.sum(self.active) # Number of active space orbitals self.nelec_tot = int( np.rint(self.mol.nelectron - np.sum(the_mf.mo_occ[self.active == 0])) ) # Total number of electrons minus frozen part # Localize the orbitals if ((self._which == 'meta_lowdin') or (self._which == 'boys')): if (self._which == 'meta_lowdin'): assert (self.norbs_tot == self.mol.nao_nr() ) # Full active space required if (self._which == 'boys'): self.ao2loc = the_mf.mo_coeff[:, self.active == 1] if (self.norbs_tot == self.mol.nao_nr() ): # If you want the full active, do meta-Lowdin nao.AOSHELL[4] = ['1s0p0d0f', '2s1p0d0f' ] # redefine the valence shell for Be self.ao2loc = orth.orth_ao(self.mol, 'meta_lowdin') if (ao_rotation != None): self.ao2loc = np.dot(self.ao2loc, ao_rotation.T) if (self._which == 'boys'): old_verbose = self.mol.verbose self.mol.verbose = 5 loc = boys.Boys(self.mol, self.ao2loc) # loc = localizer.localizer( self.mol, self.ao2loc, self._which, use_full_hessian ) self.mol.verbose = old_verbose # self.ao2loc = loc.optimize( threshold=localization_threshold ) self.ao2loc = loc.kernel() self.TI_OK = False # Check yourself if OK, then overwrite if (self._which == 'lowdin'): assert (self.norbs_tot == self.mol.nao_nr() ) # Full active space required ovlp = self.mol.intor('cint1e_ovlp_sph') ovlp_eigs, ovlp_vecs = np.linalg.eigh(ovlp) assert (np.linalg.norm( np.dot(np.dot(ovlp_vecs, np.diag(ovlp_eigs)), ovlp_vecs.T) - ovlp) < 1e-10) self.ao2loc = np.dot( np.dot(ovlp_vecs, np.diag(np.power(ovlp_eigs, -0.5))), ovlp_vecs.T) self.TI_OK = False # Check yourself if OK, then overwrite if (self._which == 'iao'): assert (self.norbs_tot == self.mol.nao_nr() ) # Full active space assumed self.ao2loc = iao_helper.localize_iao(self.mol, the_mf) if (ao_rotation != None): self.ao2loc = np.dot(self.ao2loc, ao_rotation.T) self.TI_OK = False # Check yourself if OK, then overwrite #self.molden( 'dump.molden' ) # Debugging mode assert (self.loc_ortho() < 1e-8) # Stored inverse overlap matrix self.ao_ovlp_inv = np.dot(self.ao2loc, self.ao2loc.conjugate().T) self.ao_ovlp = the_mf.get_ovlp() assert (is_matrix_eye(np.dot(self.ao_ovlp, self.ao_ovlp_inv))) # Effective Hamiltonian due to frozen part self.frozenDMmo = np.array(the_mf.mo_occ, copy=True) self.frozenDMmo[self.active == 1] = 0 # Only the frozen MO occupancies nonzero self.frozenDMao = np.dot( np.dot(the_mf.mo_coeff, np.diag(self.frozenDMmo)), the_mf.mo_coeff.T) self.frozenJKao = self.get_veff_ao( self.frozenDMao, 0, 0, 1) #Last 3 numbers: dm_last, vhf_last, hermi if self.frozenJKao.ndim == 3: self.frozenJKao = self.frozenJKao[0] # Because I gave it a spin-summed 1-RDM, the two spins for JK will necessarily be identical self.frozenOEIao = self.fullFOCKao - self.fullJKao + self.frozenJKao # Localized OEI and ERI self.oneRDM_loc = reduce(np.dot, (self.ao2loc.conjugate().T, self.ao_ovlp, self.oneRDM_loc, self.ao_ovlp, self.ao2loc)) assert (abs(np.trace(self.oneRDM_loc) - self.nelec_tot) < 1e-8), '{} {}'.format(np.trace(self.oneRDM_loc), self.nelec_tot) self.activeCONST = self.mol.energy_nuc() + np.einsum( 'ij,ij->', self.frozenOEIao - 0.5 * self.frozenJKao, self.frozenDMao) self.activeOEI = represent_operator_in_basis(self.frozenOEIao, self.ao2loc) self.activeFOCK = represent_operator_in_basis(self.fullFOCKao, self.ao2loc) self.activeJKidem = self.activeFOCK - self.activeOEI self.activeJKcorr = np.zeros((self.norbs_tot, self.norbs_tot), dtype=self.activeOEI.dtype) self.oneRDMcorr_loc = np.zeros((self.norbs_tot, self.norbs_tot), dtype=self.activeOEI.dtype) self.loc2idem = np.eye(self.norbs_tot, dtype=self.activeOEI.dtype) self.nelec_idem = self.nelec_tot self._eri = None self.with_df = None sys.stdout.flush() def _is_mem_enough(): return 2 * (self.norbs_tot** 4) / 1e6 + current_memory()[0] < self.max_memory * 0.95 # Unfortunately, there is currently no way to do the integral transformation directly on the antisymmetrized two-electron # integrals, at least none already implemented in PySCF. Therefore the smallest possible memory footprint involves # two arrays of fourfold symmetry, which works out to roughly one half of an array with no symmetry if hasattr(the_mf, 'with_df') and hasattr( the_mf.with_df, '_cderi') and the_mf.with_df._cderi is not None: print("Found density-fitting three-center integrals scf object") loc2ao = self.ao2loc.conjugate().T locOao = np.dot(loc2ao, self.ao_ovlp) self.with_df = the_mf.with_df self.with_df.loc2eri_bas = lambda x: np.dot(self.ao2loc, x) self.with_df.loc2eri_op = lambda x: reduce(np.dot, (self.ao2loc, x, loc2ao)) self.with_df.eri2loc_bas = lambda x: np.dot(locOao, x) self.with_df.eri2loc_op = lambda x: reduce(np.dot, (loc2ao, x, self .ao2loc)) elif the_mf._eri is not None: print("Found eris on scf object") loc2ao = self.ao2loc.conjugate().T locOao = np.dot(loc2ao, self.ao_ovlp) self._eri = the_mf._eri self._eri = tag_array(self._eri, loc2eri_bas=lambda x: np.dot(self.ao2loc, x)) self._eri = tag_array( self._eri, loc2eri_op=lambda x: reduce(np.dot, (self.ao2loc, x, loc2ao))) self._eri = tag_array(self._eri, eri2loc_bas=lambda x: np.dot(locOao, x)) self._eri = tag_array( self._eri, eri2loc_op=lambda x: reduce(np.dot, (loc2ao, x, self.ao2loc))) elif _is_mem_enough(): print("Storing eris in memory") self._eri = ao2mo.restore( 8, ao2mo.outcore.full_iofree(self.mol, self.ao2loc, compact=True), self.norbs_tot) self._eri = tag_array(self._eri, loc2eri_bas=lambda x: x) self._eri = tag_array(self._eri, loc2eri_op=lambda x: x) self._eri = tag_array(self._eri, eri2loc_bas=lambda x: x) self._eri = tag_array(self._eri, eri2loc_op=lambda x: x) else: print("Direct calculation") sys.stdout.flush()
def calc_mp2_ecorr_correction_to_dmetcasci_using_idempotent_1RDM( imp_case, DMET_object, idempotent_1RDM, correlated_1RDM, loc2def, norbs_frag, norbs_emb, num_zero_atol=params.num_zero_atol): norbs_tot = mrh.util.la.assert_matrix_square(idempotent_1RDM) mrh.util.la.assert_matrix_square(correlated_1RDM, matdim=norbs_tot) mrh.util.la.assert_matrix_square(loc2def, matdim=norbs_tot) assert (norbs_tot >= norbs_frag) assert (norbs_tot >= norbs_emb) norbs_froz = norbs_tot - norbs_emb if imp_case == "physical frag, overlapping bath": imp_case = "raw" # Do the Schmidt decomposition. The fragment basis functions are the first norbs_frag deformed basis functions by construction. def2frag = np.eye(norbs_emb, dtype=idempotent_1RDM.dtype)[:, :norbs_frag] loc2emb = loc2def[:, :norbs_emb] loc2froz = loc2def[:, norbs_emb:] idem_1RDM_def_basis = mrh.util.basis.represent_operator_in_basis( idempotent_1RDM, loc2emb) corr_1RDM_def_basis = mrh.util.basis.represent_operator_in_basis( correlated_1RDM, loc2emb) emb2dmeta_corr, norbs_bath_corr, nelec_imp_corr = schmidt_decompose_1RDM( corr_1RDM_def_basis, def2frag, norbs_frag) emb2dmeta, norbs_bath, nelec_imp = schmidt_decompose_1RDM( idem_1RDM_def_basis, def2frag, norbs_frag) loc2dmet = np.append(np.dot(loc2emb, emb2dmeta), loc2froz, axis=1) # Count orbitals and arrange coefficients assert (mrh.util.basis.is_basis_orthonormal_and_complete(loc2dmet)) assert (norbs_frag + norbs_bath <= norbs_emb) norbs_imp = norbs_frag + norbs_bath norbs_core = (norbs_emb - norbs_imp) + norbs_froz assert (norbs_imp + norbs_core == norbs_tot) loc2imp = loc2dmet[:, :norbs_imp] loc2core = loc2dmet[:, norbs_imp:] norbs_imp_corr = norbs_frag + norbs_bath_corr # Partition up 1RDMs core_1RDM = mrh.util.basis.project_operator_into_subspace( idempotent_1RDM, loc2core) + (correlated_1RDM - idempotent_1RDM) imp_1RDM = correlated_1RDM - core_1RDM # Count electrons; compare results for schmidt-decomposing the whole thing to schmidt-decomposing only the idempotent 1RDM nelec_tot = np.trace(correlated_1RDM) nelec_bleed = mrh.util.basis.compute_nelec_in_subspace(core_1RDM, loc2imp) report_str1 = "Decomposing the correlated 1RDM in the {0} basis leads to a {1:.3f}-electron in {2} orbital impurity problem".format( imp_case, nelec_imp_corr, norbs_imp_corr) report_str2 = "Decomposing the idempotent 1RDM in the {0} basis leads to a {1:.3f}-electron in {2} orbital impurity problem".format( imp_case, nelec_imp, norbs_imp) report_str3 = report_str2 if imp_case == "raw" else report_str1 + "\n" + report_str2 report_str4 = "in which {0} electrons from the correlated 1RDM were found bleeding on to the impurity space".format( nelec_bleed) print("{0}\n{1}".format(report_str3, report_str4)) for space, nelec in (("impurity", nelec_imp), ("total", nelec_tot)): err_str = "{0} number of {1} electrons not an even integer ({2})".format( imp_case, space, nelec) err_measure = abs(round(nelec / 2) - (nelec / 2)) assert (err_measure < num_zero_atol), err_str nelec_imp = int(round(nelec_imp)) # Perform the solver calculation and report the energy # All I want to do is read off the extra correlation energy, so I'll use pyscf_rhf and pyscf_mp2 together # The chemical potential shouldn't matter because this is a post-facto one-off correction, so there's no breaking the number # (As long as I passed the assertions a few lines above!) imp_OEI = DMET_object.ints.dmet_oei(loc2dmet, norbs_imp) imp_FOCK = DMET_object.ints.dmet_fock(loc2dmet, norbs_imp, core_1RDM) imp_TEI = DMET_object.ints.dmet_tei(loc2dmet, norbs_imp) chempot = 0.0 DMguessRHF = DMET_object.ints.dmet_init_guess_rhf(loc2dmet, norbs_imp, nelec_imp // 2, norbs_frag, chempot) mol = gto.Mole() mol.build(verbose=0) mol.atom.append(('C', (0, 0, 0))) mol.nelectron = nelec_imp mol.incore_anyway = True mf = scf.RHF(mol) mf.get_hcore = lambda *args: np.copy(imp_FOCK) mf.get_ovlp = lambda *args: np.eye(norbs_imp) mf._eri = ao2mo.restore(8, imp_TEI, norbs_imp) 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() mf.kernel() # Get the MP2 solution mp2 = mp.MP2(mf) mp2.kernel() OEI_eff = 0.5 * (imp_OEI + imp_FOCK) oneRDM_imp = mf.make_rdm1() twoRDM_imp = represent_operator_in_basis(mp2.make_rdm2(), mf.mo_coeff.T) JK = 0.5 * mf.get_veff(None, dm=oneRDM_imp) ehf_frag = 0.5 * np.einsum('ij,ij->', OEI_eff[:norbs_frag, :], oneRDM_imp[:norbs_frag, :]) ehf_frag += 0.5 * np.einsum('ij,ij->', OEI_eff[:, :norbs_frag], oneRDM_imp[:, :norbs_frag]) ehf_frag += 0.5 * np.einsum('ij,ij->', JK[:norbs_frag, :], oneRDM_imp[:norbs_frag, :]) ehf_frag += 0.5 * np.einsum('ij,ij->', JK[:, :norbs_frag], oneRDM_imp[:, :norbs_frag]) emp2_frag = 0.5 * np.einsum('ij,ij->', OEI_eff[:norbs_frag, :], oneRDM_imp[:norbs_frag, :]) emp2_frag += 0.5 * np.einsum('ij,ij->', OEI_eff[:, :norbs_frag], oneRDM_imp[:, :norbs_frag]) emp2_frag += 0.125 * np.einsum('ijkl,ijkl->', imp_TEI[:norbs_frag, :, :, :], twoRDM_imp[:norbs_frag, :, :, :]) emp2_frag += 0.125 * np.einsum('ijkl,ijkl->', imp_TEI[:, :norbs_frag, :, :], twoRDM_imp[:, :norbs_frag, :, :]) emp2_frag += 0.125 * np.einsum('ijkl,ijkl->', imp_TEI[:, :, :norbs_frag, :], twoRDM_imp[:, :, :norbs_frag, :]) emp2_frag += 0.125 * np.einsum('ijkl,ijkl->', imp_TEI[:, :, :, :norbs_frag], twoRDM_imp[:, :, :, :norbs_frag]) ecorr_frag = emp2_frag - ehf_frag print( "ehf_frag = {0:.6f}; emp2_frag = {1:.6f}; ecorr_frag = {2:.6f}".format( ehf_frag, emp2_frag, ecorr_frag)) return (mp2.e_tot - mf.e_tot)
def get_ontop_pair_density(ot, rho, ao, oneCDMs, twoCDM_amo, ao2amo, deriv=0, non0tab=None): r''' Pi(r) = i(r)*j(r)*k(r)*l(r)*d_ijkl / 2 = rho[0](r)*rho[1](r) + i(r)*j(r)*k(r)*l(r)*l_ijkl / 2 Args: ot : on-top pair density functional object rho : ndarray of shape (2,*,ngrids) contains spin density [and derivatives] ao : ndarray of shape (*, ngrids, nao) contains values of aos [and derivatives] oneCDMs : ndarray of shape (2, nao, nao) contains spin-separated 1-RDM twoCDM_amo : ndarray of shape (mc.ncas, mc.ncas, mc.ncas, mc.ncas) contains spin-summed two-body cumulant density matrix in active space ao2amo : ndarray of shape (nao, ncas) molecular-orbital coefficients for active-space orbitals Kwargs: deriv : derivative order through which to calculate. Default is 0. deriv > 1 not implemented non0tab : as in pyscf.dft.gen_grid and pyscf.dft.numint Returns : ndarray of shape (*,ngrids) The on-top pair density and its derivatives if requested deriv = 0 : value (1d array) deriv = 1 : value, d/dx, d/dy, d/dz deriv = 2 : value, d/dx, d/dy, d/dz, d^2/d|r1-r2|^2_(r1=r2) ''' # Fix dimensionality of rho and ao if rho.ndim == 2: rho = rho.reshape(rho.shape[0], 1, rho.shape[1]) if ao.ndim == 2: ao = ao.reshape(1, ao.shape[0], ao.shape[1]) # Debug code for ultra-slow, ultra-high-memory but very safe implementation if ot.verbose > logger.DEBUG: logger.debug( ot, 'Warning: memory-intensive cacheing of full 2RDM for testing ' 'purposes initiated; reduce verbosity to increase speed and memory efficiency' ) twoRDM = represent_operator_in_basis(twoCDM_amo, ao2amo.conjugate().T) twoRDM = get_2RDM_from_2CDM(twoRDM, oneCDMs) # First cumulant and derivatives (chain rule! product rule!) t0 = (time.process_time(), time.time()) Pi = np.zeros_like(rho[0]) Pi[0] = rho[0, 0] * rho[1, 0] if deriv > 0: assert (rho.shape[1] >= 4), rho.shape assert (ao.shape[0] >= 4), ao.shape for ideriv in range(1, 4): Pi[ideriv] = rho[0, ideriv] * rho[1, 0] + rho[0, 0] * rho[1, ideriv] if deriv > 1: assert (rho.shape[1] >= 6), rho.shape assert (ao.shape[0] >= 10), ao.shape Pi[4] = -(rho[:, 1:4].sum(0).conjugate() * rho[:, 1:4].sum(0)).sum(0) / 4 Pi[4] += rho[0, 0] * (rho[1, 4] / 4 + rho[0, 5] * 2) Pi[4] += rho[1, 0] * (rho[0, 4] / 4 + rho[1, 5] * 2) t0 = logger.timer_debug1(ot, 'otpd first cumulant', *t0) # Second cumulant and derivatives (chain rule! product rule!) # dot, tensordot, and sum are hugely faster than np.einsum # but whether or when they actually multithread is unclear # Update 05/11/2020: ao is actually stored in row-major order # = (deriv,AOs,grids). #grid2amo_ref = np.tensordot (ao, ao2amo, axes=1) #np.einsum ('ijk,kl->ijl', ao, ao2amo) grid2amo = _grid_ao2mo(ot.mol, ao, ao2amo, non0tab=non0tab) t0 = logger.timer(ot, 'otpd ao2mo', *t0) gridkern = np.zeros(grid2amo.shape + (grid2amo.shape[2], ), dtype=grid2amo.dtype) gridkern[0] = grid2amo[0, :, :, np.newaxis] * grid2amo[ 0, :, np.newaxis, :] # r_0ai, r_0aj -> r_0aij wrk0 = np.tensordot(gridkern[0], twoCDM_amo, axes=2) # r_0aij, P_ijkl -> P_0akl Pi[0] += (gridkern[0] * wrk0).sum((1, 2)) / 2 # r_0aij, P_0aij -> P_0a t0 = logger.timer_debug1(ot, 'otpd second cumulant 0th derivative', *t0) if ot.verbose > logger.DEBUG: logger.debug( ot, 'Warning: slow einsum-based testing calculation of Pi initiated; ' 'reduce verbosity to increase speed and memory efficiency') test_Pi = np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[0], ao[0], ao[0], ao[0]) / 2 logger.debug(ot, "Pi, |tensordot_formula - einsum_formula| = %s", linalg.norm(Pi[0] - test_Pi)) t0 = logger.timer(ot, 'otpd 0th derivative debug'.format(ideriv), *t0) if deriv > 0: for ideriv in range(1, 4): # Fourfold tensor symmetry ijkl = klij = jilk = lkji & product rule -> factor of 4 gridkern[ideriv] = grid2amo[ideriv, :, :, np.newaxis] * grid2amo[ 0, :, np.newaxis, :] # r_1ai, r_0aj -> r_1aij Pi[ideriv] += (gridkern[ideriv] * wrk0).sum( (1, 2)) * 2 # r_1aij, P_0aij -> P_1a t0 = logger.timer_debug1( ot, 'otpd second cumulant 1st derivative ({})'.format(ideriv), *t0) if ot.verbose > logger.DEBUG: logger.debug( ot, 'Warning: slow einsum-based testing calculation of Pi\'s first derivatives initiated; ' 'reduce verbosity to increase speed and memory efficiency') test_Pi = np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,aj,ai,ak,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ak,ai,aj,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,al,ai,aj,ak->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 logger.debug( ot, "Pi derivative, |tensordot_formula - einsum_formula| = %s", linalg.norm(Pi[ideriv] - test_Pi)) t0 = logger.timer( ot, 'otpd 1st derivative ({}) debug'.format(ideriv), *t0) if deriv > 1: # The fifth slot is allocated to the "off-top Laplacian," i.e., nabla_(r1-r2)^2 Pi(r1,r2)|(r1=r2) # nabla_off^2 Pi = 1/2 d^ik_jl * ([nabla_r^2 phi_i] phi_j phi_k phi_l + {1 - p_jk - p_jl}[nabla_r phi_i . nabla_r phi_j] phi_k phi_l) # using four-fold symmetry a lot! be careful! if ot.verbose > logger.DEBUG: test2_Pi = Pi[4].copy() XX, YY, ZZ = 4, 7, 9 gridkern[4] = grid2amo[[XX, YY, ZZ], :, :, np.newaxis].sum( 0) * grid2amo[0, :, np.newaxis, :] # r_2ai, r_0aj -> r_2aij gridkern[4] += (grid2amo[1:4, :, :, np.newaxis] * grid2amo[1:4, :, np.newaxis, :]).sum( 0) # r_1ai, r_1aj -> r_2aij wrk1 = np.tensordot(gridkern[1:4], twoCDM_amo, axes=2) # r_1aij, P_ijkl -> P_1akl Pi[4] += (gridkern[4] * wrk0).sum((1, 2)) / 2 # r_2aij, P_0aij -> P_2a Pi[4] -= ( (gridkern[1:4] + gridkern[1:4].transpose(0, 1, 3, 2)) * wrk1).sum( (0, 2, 3)) / 2 # r_1aij, P_1aij -> P_2a t0 = logger.timer(ot, 'otpd second cumulant off-top Laplacian', *t0) if ot.verbose > logger.DEBUG: logger.debug( ot, 'Warning: slow einsum-based testing calculation of Pi\'s second derivatives initiated; ' 'reduce verbosity to increase speed and memory efficiency') X, Y, Z = 1, 2, 3 test_Pi = np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[XX], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[YY], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[ZZ], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[X], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[Y], ao[0], ao[0]) / 2 test_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[Z], ao[0], ao[0]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[0], ao[X], ao[0]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[0], ao[Y], ao[0]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[0], ao[Z], ao[0]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[0], ao[0], ao[X]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[0], ao[0], ao[Y]) / 2 test_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[0], ao[0], ao[Z]) / 2 logger.debug( ot, 'Pi off-top Laplacian, |tensordot formula - einsum_formula| = %s', linalg.norm(Pi[4] - test_Pi)) test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[XX], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[YY], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[ZZ], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[X], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[Y], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[Z], grid2amo[0], grid2amo[0]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[0], grid2amo[X], grid2amo[0]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[0], grid2amo[Y], grid2amo[0]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[0], grid2amo[Z], grid2amo[0]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[0], grid2amo[0], grid2amo[X]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[0], grid2amo[0], grid2amo[Y]) / 2 test2_Pi -= np.einsum('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[0], grid2amo[0], grid2amo[Z]) / 2 logger.debug( ot, 'Pi off-top Laplacian, testing second cumulant only |tensordot formula - einsum_formula| = %s', linalg.norm(Pi[4] - test2_Pi)) t0 = logger.timer(ot, 'otpd off-top Laplacian debug', *t0) # Unfix dimensionality of rho, ao, and Pi if Pi.shape[0] == 1: Pi = Pi.reshape(Pi.shape[1]) rho = rho.reshape(rho.shape[0], rho.shape[2]) ao = ao.reshape(ao.shape[1], ao.shape[2]) return Pi
def setup_wm_core_scf(self, fragments, calcname): self.restore_wm_full_scf() oneRDMcorr_loc = sum((frag.oneRDMas_loc for frag in fragments)) if np.all(np.isclose(oneRDMcorr_loc, 0)): print("Null correlated 1-RDM; default settings for wm wvfn") self.activeFOCK = represent_operator_in_basis( self.fullFOCKao, self.ao2loc) self.activeJKidem = self.activeFOCK - self.activeOEI self.activeJKcorr = np.zeros((self.norbs_tot, self.norbs_tot)) self.oneRDMcorr_loc = oneRDMcorr_loc self.loc2idem = np.eye(self.norbs_tot) self.nelec_idem = self.nelec_tot return loc2corr = np.concatenate([frag.loc2amo for frag in fragments], axis=1) loc2idem = get_complementary_states(loc2corr) evecs = matrix_eigen_control_options(represent_operator_in_basis( self.loc_oei(), loc2idem), sort_vecs=1, only_nonzero_vals=False)[1] loc2idem = np.dot(loc2idem, evecs) # I want to alter the outputs of self.loc_oei (), self.loc_rhf_fock (), and the get_wm_1RDM_etc () functions. # self.loc_oei () = P_idem * (activeOEI + JKcorr) * P_idem # self.loc_rhf_fock () = P_idem * (activeOEI + JKcorr + JKidem) * P_idem # The get_wm_1RDM_etc () functions will need to add oneRDMcorr_loc to their final return value # The chemical potential is so that identically zero eigenvalues from the projection into the idem space don't get confused # with numerically-zero eigenvalues in the idem space: all occupied orbitals must have negative energy # Make true output 1RDM from fragments to use as guess for wm mcscf calculation oneRDMguess_loc = np.zeros_like(oneRDMcorr_loc) for f in itertools.product(fragments, fragments): loc2frag = [i.loc2frag for i in f] oneRDMguess_loc += sum( (0.5 * project_operator_into_subspace(i.oneRDM_loc, *loc2frag) for i in f)) nelec_corr = np.trace(oneRDMcorr_loc) if is_close_to_integer(nelec_corr, 100 * params.num_zero_atol) == False: raise ValueError( "nelec_corr not an integer! {}".format(nelec_corr)) nelec_idem = int(round(self.nelec_tot - nelec_corr)) JKcorr = self.loc_rhf_jk_bis(oneRDMcorr_loc) oneRDMidem_loc = self.get_wm_1RDM_from_scf_on_OEI( self.loc_oei() + JKcorr, nelec=nelec_idem, loc2wrk=loc2idem, oneRDMguess_loc=oneRDMguess_loc, output=calcname + '_trial_wvfn.log') JKidem = self.loc_rhf_jk_bis(oneRDMidem_loc) print("trace of oneRDMcorr_loc = {}".format(np.trace(oneRDMcorr_loc))) print("trace of oneRDMidem_loc = {}".format(np.trace(oneRDMidem_loc))) print("trace of oneRDM_loc in corr basis = {}".format( np.trace( represent_operator_in_basis( oneRDMcorr_loc + oneRDMidem_loc, orthonormalize_a_basis(loc2corr))))) svals = get_overlapping_states(loc2idem, loc2corr)[2] print("trace of <idem|corr|idem> = {}".format(np.sum(svals * svals))) print(loc2corr.shape) print(loc2idem.shape) ######################################################################################################## self.activeFOCK = self.activeOEI + JKidem + JKcorr self.activeJKidem = JKidem self.activeJKcorr = JKcorr self.oneRDMcorr_loc = oneRDMcorr_loc self.loc2idem = loc2idem self.nelec_idem = nelec_idem ######################################################################################################## # Analysis: 1RDM and total energy print("Analyzing LASSCF trial wave function") oei = self.activeOEI + (JKcorr + JKidem) / 2 fock = self.activeFOCK oneRDM = oneRDMidem_loc + oneRDMcorr_loc E = self.activeCONST + np.tensordot(oei, oneRDM, axes=2) for frag in fragments: if frag.norbs_as > 0: if frag.E2_cum == 0 and np.amax(np.abs( frag.twoCDMimp_amo)) > 0: V = self.dmet_tei(frag.loc2amo) L = frag.twoCDMimp_amo frag.E2_cum = np.tensordot(V, L, axes=4) / 2 E += frag.E2_cum print("LASSCF trial wave function total energy: {:.6f}".format(E)) self.oneRDM_loc = oneRDM self.e_tot = E # Molden fock_idem = represent_operator_in_basis(fock, loc2idem) oneRDM_corr = represent_operator_in_basis(oneRDM, loc2corr) idem_evecs = matrix_eigen_control_options(fock_idem, sort_vecs=1, only_nonzero_vals=False)[1] corr_evecs = matrix_eigen_control_options(oneRDM_corr, sort_vecs=-1, only_nonzero_vals=False)[1] loc2molden = np.append(np.dot(loc2idem, idem_evecs), np.dot(loc2corr, corr_evecs), axis=1) wm_ene = np.einsum('ip,ij,jp->p', loc2molden, fock, loc2molden) wm_ene[-loc2corr.shape[1]:] = 0 wm_occ = np.einsum('ip,ij,jp->p', loc2molden, oneRDM, loc2molden) ao2molden = np.dot(self.ao2loc, loc2molden) molden.from_mo(self.mol, calcname + '_trial_wvfn.molden', ao2molden, occ=wm_occ, ene=wm_ene)
def project_amo_manually (loc2imp, loc2gamo, fock_mf, norbs_cmo, dm=None): norbs_amo = loc2gamo.shape[1] amo2imp = np.dot (loc2gamo.conjugate ().T, loc2imp) ovlp = np.dot (amo2imp, amo2imp.conjugate ().T) ''' print ("Do impurity orbitals span guess amos?") print (prettyprint (ovlp, fmt='{:5.2f}')) if dm is not None: print ("Density matrix?") print (prettyprint (represent_operator_in_basis (dm, loc2gamo), fmt='{:5.2f}')) ''' proj = np.dot (amo2imp.conjugate ().T, amo2imp) evals, evecs = matrix_eigen_control_options (proj, sort_vecs=-1, only_nonzero_vals=False) imp2amo = np.copy (evecs[:,:norbs_amo]) imp2imo = np.copy (evecs[:,norbs_amo:]) fock_imo = represent_operator_in_basis (fock_mf, imp2imo) _, evecs = matrix_eigen_control_options (fock_imo, sort_vecs=1, only_nonzero_vals=False) imp2imo = np.dot (imp2imo, evecs) imp2cmo = imp2imo[:,:norbs_cmo] imp2vmo = imp2imo[:,norbs_cmo:] # Sort amo in order to apply stored ci vector imp2gamo = np.dot (loc2imp.conjugate ().T, loc2gamo) amoOgamo = np.dot (imp2amo.conjugate ().T, imp2gamo) #print ("Overlap matrix between guess-active and active:") #print (prettyprint (amoOgamo, fmt='{:5.2f}')) Pgamo1_amo = np.einsum ('ik,jk->ijk', amoOgamo, amoOgamo.conjugate ()) imp2ramo = np.zeros_like (imp2amo) ramo_evals = np.zeros (imp2ramo.shape[1], dtype=imp2ramo.dtype) while (Pgamo1_amo.shape[0] > 0): max_eval = 0 argmax_eval = -1 argmax_evecs = None for idx in range (Pgamo1_amo.shape[2]): evals, evecs = matrix_eigen_control_options (Pgamo1_amo[:,:,idx], sort_vecs=-1, only_nonzero_vals=False) if evals[0] > max_eval: max_eval = evals[0] max_evecs = evecs argmax_eval = idx #print ("With {} amos to go, assigned highest eigenvalue ({}) to {}".format (Pgamo1_amo.shape[0], max_eval, argmax_eval)) ramo_evals[argmax_eval] = max_eval imp2ramo[:,argmax_eval] = np.einsum ('ij,j->i', imp2amo, max_evecs[:,0]) imp2amo = np.dot (imp2amo, max_evecs[:,1:]) amoOgamo = np.dot (imp2amo.conjugate ().T, imp2gamo) Pgamo1_amo = np.einsum ('ik,jk->ijk', amoOgamo, amoOgamo.conjugate ()) imp2amo = imp2ramo print ("Fidelity of projection of guess active orbitals onto impurity space:\n{}".format (ramo_evals)) amoOgamo = np.dot (imp2amo.conjugate ().T, imp2gamo) idx_signflip = np.diag (amoOgamo) < 0 imp2amo[:,idx_signflip] *= -1 amoOgamo = np.dot (imp2amo.conjugate ().T, imp2gamo) ''' print ("Overlap matrix between guess-active and active:") print (prettyprint (amoOgamo, fmt='{:5.2f}')) O = np.dot (imp2amo.conjugate ().T, imp2amo) - np.eye (imp2amo.shape[1]) print ("Overlap error between active and active: {}".format (linalg.norm (O))) O = np.dot (imp2amo.conjugate ().T, imp2cmo) print ("Overlap error between active and occupied: {}".format (linalg.norm (O))) O = np.dot (imp2amo.conjugate ().T, imp2vmo) print ("Overlap error between active and virtual: {}".format (linalg.norm (O))) ''' my_occ = np.zeros (loc2imp.shape[1], dtype=np.float64) my_occ[:norbs_cmo] = 2 my_occ[norbs_cmo:][:imp2amo.shape[1]] = 1 if dm is not None: loc2amo = np.dot (loc2imp, imp2amo) evals, evecs = matrix_eigen_control_options (represent_operator_in_basis (dm, loc2amo), sort_vecs=-1, only_nonzero_vals=False) imp2amo = np.dot (imp2amo, evecs) print ("Guess density matrix eigenvalues for guess amo: {}".format (evals)) my_occ[norbs_cmo:][:imp2amo.shape[1]] = evals imp2mo = np.concatenate ([imp2cmo, imp2amo, imp2vmo], axis=1) return imp2mo, my_occ
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
def loc_ortho(self): # ShouldBeI = np.dot( np.dot( self.ao2loc.T , self.mol.intor('cint1e_ovlp_sph') ) , self.ao2loc ) ShouldBeI = represent_operator_in_basis(self.fullovlpao(), self.ao2loc) return np.linalg.norm(ShouldBeI - np.eye(ShouldBeI.shape[0]))
def get_ontop_pair_density (ot, rho, ao, oneCDMs, twoCDM_amo, ao2amo, deriv=0): r''' Pi(r) = i(r)*j(r)*k(r)*l(r)*g_ijkl / 2 = rho[0](r)*rho[1](r) + i(r)*j(r)*k(r)*l(r)*l_ijkl / 2 Args: ot : on-top pair density functional object rho : ndarray of shape (2,*,ngrids) contains spin density [and derivatives] ao : ndarray of shape (*, ngrids, nao) contains values of aos [and derivatives] oneCDMs : ndarray of shape (2, nao, nao) contains spin-separated 1-RDM twoCDM_amo : ndarray of shape (mc.ncas, mc.ncas, mc.ncas, mc.ncas) contains spin-summed two-body cumulant density matrix in active space ao2amo : ndarray of shape (nao, ncas) molecular-orbital coefficients for active-space orbitals Kwargs: deriv : derivative order through which to calculate. Default is 0. deriv > 1 not implemented Returns : ndarray of shape (*,ngrids) The on-top pair density and its derivatives if requested deriv = 0 : value (1d array) deriv = 1 : value, d/dx, d/dy, d/dz deriv = 2 : value, d/dx, d/dy, d/dz, d^2/d|r1-r2|^2_(r1=r2) ''' assert (rho.ndim == ao.ndim), "rho.shape={0}; ao.shape={1}".format (rho.shape, ao.shape) # Fix dimensionality of rho and ao if rho.ndim == 2: rho = rho.reshape (rho.shape[0], 1, rho.shape[1]) ao = ao.reshape (1, ao.shape[0], ao.shape[1]) # Debug code for ultra-slow, ultra-high-memory but very safe implementation if ot.verbose > logger.DEBUG: twoRDM = represent_operator_in_basis (twoCDM_amo, ao2amo.conjugate ().T) twoRDM = get_2RDM_from_2CDM (twoRDM, oneCDMs) # First cumulant and derivatives (chain rule! product rule!) t0 = (time.clock (), time.time ()) Pi = np.zeros_like (rho[0]) Pi[0] = rho[0,0] * rho[1,0] if deriv > 0: assert (rho.shape[1] >= 4), rho.shape assert (ao.shape[0] >= 4), ao.shape for ideriv in range(1,4): Pi[ideriv] = rho[0,ideriv]*rho[1,0] + rho[0,0]*rho[1,ideriv] if deriv > 1: assert (rho.shape[1] >= 6), rho.shape assert (ao.shape[0] >= 10), ao.shape Pi[4] = -(rho[:,1:4].sum (0).conjugate () * rho[:,1:4].sum (0)).sum (0) / 4 Pi[4] += rho[0,0]*(rho[1,4]/4 + rho[0,5]*2) Pi[4] += rho[1,0]*(rho[0,4]/4 + rho[1,5]*2) t0 = logger.timer (ot, 'otpd first cumulant', *t0) # Second cumulant and derivatives (chain rule! product rule!) # np.multiply, np.sum, and np.tensordot are linked against compiled libraries with multithreading, but np.einsum is not # Therefore I abandon the use of np.einsum # ijkl, ai, aj, ak, al -> a grid2amo = np.tensordot (ao, ao2amo, axes=1) #np.einsum ('ijk,kl->ijl', ao, ao2amo) gridkern = np.zeros (grid2amo.shape + (grid2amo.shape[2],), dtype=grid2amo.dtype) gridkern[0] = grid2amo[0,:,:,np.newaxis] * grid2amo[0,:,np.newaxis,:] # r_0ai, r_0aj -> r_0aij wrk0 = np.tensordot (gridkern[0], twoCDM_amo, axes=2) # r_0aij, P_ijkl -> P_0akl Pi[0] += (gridkern[0] * wrk0).sum ((1,2)) / 2 # r_0aij, P_0aij -> P_0a t0 = logger.timer (ot, 'otpd second cumulant 0th derivative', *t0) if ot.verbose > logger.DEBUG: test_Pi = np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[0], ao[0], ao[0], ao[0]) / 2 logger.debug (ot, "Pi, |tensordot_formula - einsum_formula| = %s", linalg.norm (Pi[0] - test_Pi)) t0 = logger.timer (ot, 'otpd 0th derivative debug'.format (ideriv), *t0) if deriv > 0: for ideriv in range (1, 4): # Fourfold tensor symmetry ijkl = klij = jilk = lkji & product rule -> factor of 4 gridkern[ideriv] = grid2amo[ideriv,:,:,np.newaxis] * grid2amo[0,:,np.newaxis,:] # r_1ai, r_0aj -> r_1aij Pi[ideriv] += (gridkern[ideriv] * wrk0).sum ((1,2)) * 2 # r_1aij, P_0aij -> P_1a t0 = logger.timer (ot, 'otpd second cumulant 1st derivative ({})'.format (ideriv), *t0) if ot.verbose > logger.DEBUG: test_Pi = np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,aj,ai,ak,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ak,ai,aj,al->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,al,ai,aj,ak->a', twoRDM, ao[ideriv], ao[0], ao[0], ao[0]) / 2 logger.debug (ot, "Pi derivative, |tensordot_formula - einsum_formula| = %s", linalg.norm (Pi[ideriv] - test_Pi)) t0 = logger.timer (ot, 'otpd 1st derivative ({}) debug'.format (ideriv), *t0) if deriv > 1: # The fifth slot is allocated to the "off-top Laplacian," i.e., nabla_(r1-r2)^2 Pi(r1,r2)|(r1=r2) # nabla_off^2 Pi = 1/2 d^ik_jl * ([nabla_r^2 phi_i] phi_j phi_k phi_l + {1 - p_jk - p_jl}[nabla_r phi_i . nabla_r phi_j] phi_k phi_l) # using four-fold symmetry a lot! be careful! if ot.verbose > logger.DEBUG: test2_Pi = Pi[4].copy () XX, YY, ZZ = 4, 7, 9 gridkern[4] = grid2amo[[XX,YY,ZZ],:,:,np.newaxis].sum (0) * grid2amo[0,:,np.newaxis,:] # r_2ai, r_0aj -> r_2aij gridkern[4] += (grid2amo[1:4,:,:,np.newaxis] * grid2amo[1:4,:,np.newaxis,:]).sum (0) # r_1ai, r_1aj -> r_2aij wrk1 = np.tensordot (gridkern[1:4], twoCDM_amo, axes=2) # r_1aij, P_ijkl -> P_1akl Pi[4] += (gridkern[4] * wrk0).sum ((1,2)) / 2 # r_2aij, P_0aij -> P_2a Pi[4] -= ((gridkern[1:4] + gridkern[1:4].transpose (0, 1, 3, 2)) * wrk1).sum ((0,2,3)) / 2 # r_1aij, P_1aij -> P_2a t0 = logger.timer (ot, 'otpd second cumulant off-top Laplacian', *t0) if ot.verbose > logger.DEBUG: X, Y, Z = 1, 2, 3 test_Pi = np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[XX], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[YY], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[ZZ], ao[0], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[X], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[Y], ao[0], ao[0]) / 2 test_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[Z], ao[0], ao[0]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[0], ao[X], ao[0]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[0], ao[Y], ao[0]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[0], ao[Z], ao[0]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[X], ao[0], ao[0], ao[X]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Y], ao[0], ao[0], ao[Y]) / 2 test_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoRDM, ao[Z], ao[0], ao[0], ao[Z]) / 2 logger.debug (ot, 'Pi off-top Laplacian, |tensordot formula - einsum_formula| = %s', linalg.norm (Pi[4] - test_Pi)) test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[XX], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[YY], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[ZZ], grid2amo[0], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[X], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[Y], grid2amo[0], grid2amo[0]) / 2 test2_Pi += np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[Z], grid2amo[0], grid2amo[0]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[0], grid2amo[X], grid2amo[0]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[0], grid2amo[Y], grid2amo[0]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[0], grid2amo[Z], grid2amo[0]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[X], grid2amo[0], grid2amo[0], grid2amo[X]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Y], grid2amo[0], grid2amo[0], grid2amo[Y]) / 2 test2_Pi -= np.einsum ('ijkl,ai,aj,ak,al->a', twoCDM_amo, grid2amo[Z], grid2amo[0], grid2amo[0], grid2amo[Z]) / 2 logger.debug (ot, 'Pi off-top Laplacian, testing second cumulant only |tensordot formula - einsum_formula| = %s', linalg.norm (Pi[4] - test2_Pi)) t0 = logger.timer (ot, 'otpd off-top Laplacian debug', *t0) # Unfix dimensionality of rho, ao, and Pi if Pi.shape[0] == 1: Pi = Pi.reshape (Pi.shape[1]) rho = rho.reshape (rho.shape[0], rho.shape[2]) ao = ao.reshape (ao.shape[1], ao.shape[2]) return Pi
def solve(frag, guess_1RDM, chempot_imp): t_start = time.time() # Augment OEI with the chemical potential OEI = frag.impham_OEI - chempot_imp # 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 4 mol.output = frag.mol_output mol.build() mol.atom.append(('C', (0, 0, 0))) mol.nelectron = frag.nelec_imp mol.incore_anyway = True mf = scf.RHF(mol) mf.get_hcore = lambda *args: OEI mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp) if frag.quasidirect: mf.get_jk = frag.impham_get_jk else: mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) mf.__dict__.update(frag.mf_attr) mf.scf(guess_1RDM) if (mf.converged == False): mf = mf.newton() mf.kernel() # Instability check and repeat for i in range(frag.num_mf_stab_checks): new_mo = mf.stability()[0] guess_1RDM = reduce(np.dot, (new_mo, np.diag(mf.mo_occ), new_mo.conjugate().T)) mf = scf.RHF(mol) mf.get_hcore = lambda *args: OEI mf.get_ovlp = lambda *args: np.eye(frag.norbs_imp) if frag.quasidirect: mf.get_jk = frag.impham_get_jk else: mf._eri = ao2mo.restore(8, frag.impham_TEI, frag.norbs_imp) mf.scf(guess_1RDM) if (mf.converged == False): mf = mf.newton() mf.kernel() oneRDMimp_imp = mf.make_rdm1() print("Maximum distance between oneRDMimp_imp and guess_1RDM: {}".format( np.amax(np.abs(oneRDMimp_imp - guess_1RDM)))) frag.oneRDM_loc = symmetrize_tensor( frag.oneRDMfroz_loc + represent_operator_in_basis(oneRDMimp_imp, frag.imp2loc)) frag.twoCDM_imp = None frag.E_imp = frag.impham_CONST + mf.e_tot + np.einsum( 'ab,ab->', oneRDMimp_imp, chempot_imp) frag.loc2mo = np.dot(frag.loc2imp, mf.mo_coeff) print("Time for impurity RHF: {} seconds".format(time.time() - t_start)) return None