def get_pi_space_local_split(mol, mf, cas_norb, cas_nel):
# {{{
from pyscf import mcscf, mo_mapping, lo, ao2mo
# find the 2pz orbitals using mo_mapping
ao_labels = ['C 2pz']
pop = mo_mapping.mo_comps(ao_labels, mol, mf.mo_coeff)
cas_list = np.sort(
pop.argsort()
[-cas_norb:]) #take the 2z orbitals and resort in MO order
print('Population for pz orbitals', pop[cas_list])
mo_occ = np.where(mf.mo_occ > 0)[0]
focc_list = list(set(mo_occ) - set(cas_list))
mo_vir = np.where(mf.mo_occ == 0)[0]
fvir_list = list(set(mo_vir) - set(cas_list))
focc = len(focc_list)
# localize the active space
C = mf.mo_coeff
##### New stuff
occ_l = cas_list[:cas_norb // 2]
occ_v = cas_list[cas_norb // 2:]
if 0:
boys = lo.Boys(mol, mf.mo_coeff[:, occ_l])
#boys.init_guess = None
cl_a = boys.kernel()
boys = lo.Boys(mol, mf.mo_coeff[:, occ_v])
#boys.init_guess = None
cl_b = boys.kernel()
else:
cl_a = lo.Boys(mol, mf.mo_coeff[:, occ_l]).kernel(verbose=4)
cl_b = lo.Boys(mol, mf.mo_coeff[:, occ_v]).kernel(verbose=4)
C[:, occ_l] = cl_a
C[:, occ_v] = cl_b
# reorder the orbitals to get docc,active,vir ordering (Note:sort mo takes orbital ordering from 1)
mycas = mcscf.CASCI(mf, cas_norb, cas_nel)
C = mycas.sort_mo(cas_list + 1, mo_coeff=C)
# Get the active space integrals and the frozen core energy
h, ecore = mycas.get_h1eff(C)
g = ao2mo.kernel(mol,
C[:, focc:focc + cas_norb],
aosym='s4',
compact=False).reshape(4 * ((cas_norb), ))
C = C[:, focc:focc + cas_norb] #only carrying the active sapce orbs
return h, ecore, g, C
def build_iAO_basis(mol, Cf, Cf_core, Cf_vale, nfreeze):
import numpy as np
import scipy.linalg as sla
S_f = mol.intor_symmetric('cint1e_ovlp_sph')
nup = mol.nelectron // 2
iao, Cf_core = build_iao(S_f,
Cf[:, :nup],
Cf_vale,
P_core=Cf_core,
nfreeze=nfreeze)
# loc = localizer.localizer(mol,iao,'boys')
# loc.verbose = 5
# iao_loc = loc.optimize (threshold=1.0e-5)
# del loc
iao_loc = lo.Boys(mol, iao).kernel()
# need to find occupied orbitals orthogonal to core
if (Cf_core is not None):
Cf_x = project(Cf[:, :nup], S_f, Cf_core, 'out')
return iao_loc, Cf_core, Cf_x
#print("CFX shape", Cf_x.shape)
exit()
else:
Cf_x = Cf[:, :nup]
#print("CFX shape", Cf_x.shape)
exit()
return iao_loc, None, Cf_x
def loc_orbs(mol: gto.Mole, mo_coeff: Tuple[np.ndarray, np.ndarray], \
s: np.ndarray, ref: str, variant: str) -> np.ndarray:
"""
this function returns a set of localized MOs of a specific variant
"""
# loop over spins
for i, spin_mo in enumerate((mol.alpha, mol.beta)):
if variant == 'fb':
# foster-boys procedure
loc = lo.Boys(mol, mo_coeff[i][:, spin_mo])
loc.conv_tol = LOC_CONV
# FB MOs
mo_coeff[i][:, spin_mo] = loc.kernel()
elif variant == 'pm':
# pipek-mezey procedure
loc = lo.PM(mol, mo_coeff[i][:, spin_mo])
loc.conv_tol = LOC_CONV
# PM MOs
mo_coeff[i][:, spin_mo] = loc.kernel()
elif 'ibo' in variant:
# orthogonalized IAOs
iao = lo.iao.iao(mol, mo_coeff[i][:, spin_mo])
iao = lo.vec_lowdin(iao, s)
# IBOs
mo_coeff[i][:, spin_mo] = lo.ibo.ibo(mol, mo_coeff[i][:, spin_mo], iaos=iao, \
grad_tol = LOC_CONV, exponent=int(variant[-1]), verbose=0)
# closed-shell reference
if ref == 'restricted' and mol.spin == 0:
mo_coeff[i + 1][:, spin_mo] = mo_coeff[i][:, spin_mo]
break
return mo_coeff
def get_pi_space(mol, mf, cas_norb, cas_nel, local=True, p3=False):
# {{{
from pyscf import mcscf, mo_mapping, lo, ao2mo
# find the 2pz orbitals using mo_mapping
ao_labels = ['C 2pz']
# get the 3pz and 2pz orbitals
if p3:
ao_labels = ['C 2pz', 'C 3pz']
cas_norb = 2 * cas_norb
pop = mo_mapping.mo_comps(ao_labels, mol, mf.mo_coeff)
cas_list = np.sort(
pop.argsort()
[-cas_norb:]) #take the 2z orbitals and resort in MO order
print('Population for pz orbitals', pop[cas_list])
mo_occ = np.where(mf.mo_occ > 0)[0]
focc_list = list(set(mo_occ) - set(cas_list))
focc = len(focc_list)
# localize the active space
if local:
cl_a = lo.Boys(mol, mf.mo_coeff[:, cas_list]).kernel(verbose=4)
C = mf.mo_coeff
C[:, cas_list] = cl_a
else:
C = mf.mo_coeff
mo_energy = mf.mo_energy[cas_list]
J, K = mf.get_jk()
K = K[cas_list, :][:, cas_list]
print(K)
if mol.symmetry == True:
from pyscf import symm
mo = symm.symmetrize_orb(mol, C[:, cas_list])
osym = symm.label_orb_symm(mol, mol.irrep_name, mol.symm_orb, mo)
#symm.addons.symmetrize_space(mol, mo, s=None, check=True, tol=1e-07)
for i in range(len(osym)):
print("%4d %8s %16.8f" % (i + 1, osym[i], mo_energy[i]))
# reorder the orbitals to get docc,active,vir ordering (Note:sort mo takes orbital ordering from 1)
mycas = mcscf.CASCI(mf, cas_norb, cas_nel)
C = mycas.sort_mo(cas_list + 1, mo_coeff=C)
np.save('C.npy', C)
# Get the active space integrals and the frozen core energy
h, ecore = mycas.get_h1eff(C)
g = ao2mo.kernel(mol,
C[:, focc:focc + cas_norb],
aosym='s4',
compact=False).reshape(4 * ((cas_norb), ))
C = C[:, focc:focc + cas_norb] #only carrying the active sapce orbs
return h, ecore, g, C
def IAO_construction(mol, mf, nfreeze=0):
rho = mf.make_rdm1()
nb = mol.nao_nr()
S = mf.get_ovlp()
C_oc = mf.mo_coeff[:, mf.mo_occ > 0]
C_vl = np.zeros((nb, nb))
cs, cf = 0, 0
if (type(mol.atom) != list):
mol_atom = mol.atom.split(';')
mol_atom = [list(x.split()) for x in mol_atom]
mol_atom = [[x[0], (x[1], x[2], x[3])] for x in mol_atom]
else:
mol_atom = mol.atom
for [a, x], (sh0, sh1, ao0, ao1) in zip(mol_atom, mol.offset_nr_by_atom()):
pmol = gto.Mole()
pmol.atom = [[a, (0.0, 0.0, 0.0)]]
pmol.basis = mol.basis
pmol.charge = 0
pmol.verbose = 0
pmol.spin = atomic_spins[a]
pmol.symmetry = True
pmol.build()
pmf = scf.ROHF(pmol)
pmf.kernel()
C_vl_a = pmf.mo_coeff[:, :minimal_basis_size[a]]
cf = cs + C_vl_a.shape[1]
C_vl[ao0:ao1, cs:cf] = C_vl_a[:, :]
cs = cf
C_vl = C_vl[:, :cf]
Px = orthonormalize(C_vl, S, 'orthonormalize')
C_oc_p = project(Px, S, C_oc, 'along')
M1 = projector(C_oc, S)
M2 = projector(C_oc_p, S)
IAO = np.dot(np.dot(M1, M2), Px) + np.dot(
np.dot(np.eye(nb) - M1,
np.eye(nb) - M2), Px)
IAO = orthonormalize(IAO, S, 'orthonormalize')
IAO = lo.Boys(mol, IAO).kernel()
if (nfreeze > 0):
C_freeze = C_oc[:, :nfreeze]
IAO_unfrozen = project(IAO, S, C_freeze, 'outside')
IAO[:, :nfreeze] = C_freeze[:, :]
IAO[:, nfreeze:] = IAO_unfrozen[:, :]
return IAO
from pyscf import lo
from pyscf.tools import molden
mol = gto.M(
atom = '''
C 0.000000000000 1.398696930758 0.000000000000
C 0.000000000000 -1.398696930758 0.000000000000
C 1.211265339156 0.699329968382 0.000000000000
C 1.211265339156 -0.699329968382 0.000000000000
C -1.211265339156 0.699329968382 0.000000000000
C -1.211265339156 -0.699329968382 0.000000000000
H 0.000000000000 2.491406946734 0.000000000000
H 0.000000000000 -2.491406946734 0.000000000000
H 2.157597486829 1.245660462400 0.000000000000
H 2.157597486829 -1.245660462400 0.000000000000
H -2.157597486829 1.245660462400 0.000000000000
H -2.157597486829 -1.245660462400 0.000000000000''',
basis = '6-31g')
mf = scf.RHF(mol).run()
pz_idx = numpy.array([17,20,21,22,23,30,36,41,42,47,48,49])-1
loc_orb = lo.Boys(mol, mf.mo_coeff[:,pz_idx]).kernel()
molden.from_mo(mol, 'boys.molden', loc_orb)
loc_orb = lo.ER(mol, mf.mo_coeff[:,pz_idx]).kernel()
molden.from_mo(mol, 'edmiston.molden', loc_orb)
loc_orb = lo.PM(mol, mf.mo_coeff[:,pz_idx]).kernel()
molden.from_mo(mol, 'pm.molden', loc_orb)
Cocc = C[:,i].reshape(C.shape[0],1)
temp = Cocc @ Cocc.T @ S
for m,lb in enumerate(mol.ao_labels()):
print(lb)
v1,v2,v3 = lb.split()
print(v1)
mulliken[int(v1),i] += temp[m,m]
print(mulliken)
return mulliken
# }}}
local = False
local = True
if local:
cl_c = mf.mo_coeff[:, focc_list]
cl_a = lo.Boys(mol, mf.mo_coeff[:, cas_list]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, fvir_list]
C = np.column_stack((cl_c, cl_a, cl_v))
else:
cl_c = mf.mo_coeff[:, focc_list]
cl_a = mf.mo_coeff[:, cas_list]
cl_v = mf.mo_coeff[:, fvir_list]
C = np.column_stack((cl_c, cl_a, cl_v))
from pyscf import mo_mapping
s_pop = mo_mapping.mo_comps('C 2pz', mol, C)
print(s_pop)
cas_list = s_pop.argsort()[-cas_norb:]
print('cas_list', np.array(cas_list))
print('s population for active space orbitals', s_pop[cas_list])
focc_list = list(set(mo_occ)-set(cas_list))
def init(self,molecule,charge,spin,basis_set,orb_basis='scf',cas=False,cas_nstart=None,cas_nstop=None,cas_nel=None,loc_nstart=None,loc_nstop=None,
scf_conv_tol=1e-14):
# {{{
import pyscf
from pyscf import gto, scf, ao2mo, molden, lo
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
#PYSCF inputs
print(" ---------------------------------------------------------")
print(" Using Pyscf:")
print(" ---------------------------------------------------------")
print(" ")
mol = gto.Mole()
mol.atom = molecule
mol.max_memory = 1000 # MB
mol.symmetry = True
mol.charge = charge
mol.spin = spin
mol.basis = basis_set
mol.build()
print("symmertry")
print(mol.topgroup)
#SCF
#mf = scf.RHF(mol).run(init_guess='atom')
mf = scf.RHF(mol).run(conv_tol=scf_conv_tol)
#C = mf.mo_coeff #MO coeffs
enu = mf.energy_nuc()
print(" SCF Total energy: %12.8f" %mf.e_tot)
print(" SCF Elec energy: %12.8f" %(mf.e_tot-enu))
print(mf.get_fock())
print(np.linalg.eig(mf.get_fock())[0])
if mol.symmetry == True:
from pyscf import symm
mo = symm.symmetrize_orb(mol, mf.mo_coeff)
osym = symm.label_orb_symm(mol, mol.irrep_name, mol.symm_orb, mo)
#symm.addons.symmetrize_space(mol, mo, s=None, check=True, tol=1e-07)
for i in range(len(osym)):
print("%4d %8s %16.8f"%(i+1,osym[i],mf.mo_energy[i]))
#orbitals and lectrons
n_orb = mol.nao_nr()
n_b , n_a = mol.nelec
nel = n_a + n_b
self.n_orb = mol.nao_nr()
if cas == True:
cas_norb = cas_nstop - cas_nstart
from pyscf import mcscf
assert(cas_nstart != None)
assert(cas_nstop != None)
assert(cas_nel != None)
else:
cas_nstart = 0
cas_nstop = n_orb
cas_nel = nel
##AO 2 MO Transformation: orb_basis or scf
if orb_basis == 'scf':
print("\nUsing Canonical Hartree Fock orbitals...\n")
C = cp.deepcopy(mf.mo_coeff)
print("C shape")
print(C.shape)
elif orb_basis == 'lowdin':
assert(cas == False)
S = mol.intor('int1e_ovlp_sph')
print("Using lowdin orthogonalized orbitals")
C = lowdin(S)
#end
elif orb_basis == 'boys':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :cas_nstart]
cl_a = lo.Boys(mol, mf.mo_coeff[:, cas_nstart:cas_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, cas_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'boys2':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :loc_nstart]
cl_a = lo.Boys(mol, mf.mo_coeff[:, loc_nstart:loc_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, loc_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'PM':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :cas_nstart]
cl_a = lo.PM(mol, mf.mo_coeff[:, cas_nstart:cas_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, cas_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'PM2':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :loc_nstart]
cl_a = lo.PM(mol, mf.mo_coeff[:, loc_nstart:loc_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, loc_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'ER':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :cas_nstart]
cl_a = lo.PM(mol, mf.mo_coeff[:, cas_nstart:cas_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, cas_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'ER2':
pyscf.lib.num_threads(1) #with degenerate states and multiple processors there can be issues
cl_c = mf.mo_coeff[:, :loc_nstart]
cl_a = lo.ER(mol, mf.mo_coeff[:, loc_nstart:loc_nstop]).kernel(verbose=4)
cl_v = mf.mo_coeff[:, loc_nstop:]
C = np.column_stack((cl_c, cl_a, cl_v))
elif orb_basis == 'ibmo':
loc_vstop = loc_nstop - n_a
print(loc_vstop)
mo_occ = mf.mo_coeff[:,mf.mo_occ>0]
mo_vir = mf.mo_coeff[:,mf.mo_occ==0]
c_core = mo_occ[:,:loc_nstart]
iao_occ = lo.iao.iao(mol, mo_occ[:,loc_nstart:])
iao_vir = lo.iao.iao(mol, mo_vir[:,:loc_vstop])
c_out = mo_vir[:,loc_vstop:]
# Orthogonalize IAO
iao_occ = lo.vec_lowdin(iao_occ, mf.get_ovlp())
iao_vir = lo.vec_lowdin(iao_vir, mf.get_ovlp())
#
# Method 1, using Knizia's alogrithm to localize IAO orbitals
#
'''
Generate IBOS from orthogonal IAOs
'''
ibo_occ = lo.ibo.ibo(mol, mo_occ[:,loc_nstart:], iaos = iao_occ)
ibo_vir = lo.ibo.ibo(mol, mo_vir[:,:loc_vstop], iaos = iao_vir)
C = np.column_stack((c_core,ibo_occ,ibo_vir,c_out))
else:
print("Error:NO orbital basis defined")
molden.from_mo(mol, 'orbitals.molden', C)
if cas == True:
print(C.shape)
print(cas_norb)
print(cas_nel)
mycas = mcscf.CASSCF(mf, cas_norb, cas_nel)
h1e_cas, ecore = mycas.get_h1eff(mo_coeff = C) #core core orbs to form ecore and eff
h2e_cas = ao2mo.kernel(mol, C[:,cas_nstart:cas_nstop], aosym='s4',compact=False).reshape(4 * ((cas_norb), ))
print(h1e_cas)
print(h1e_cas.shape)
#return h1e_cas,h2e_cas,ecore,C,mol,mf
self.h = h1e_cas
self.g = h2e_cas
self.ecore = ecore
self.mf = mf
self.mol = mol
self.C = cp.deepcopy(C[:,cas_nstart:cas_nstop])
J,K = mf.get_jk()
self.J = self.C.T @ J @ self.C
self.K = self.C.T @ J @ self.C
#HF density
if orb_basis == 'scf':
#C = C[:,cas_nstart:cas_nstop]
D = mf.make_rdm1(mo_coeff=C)
S = mf.get_ovlp()
sal, svec = np.linalg.eigh(S)
idx = sal.argsort()[::-1]
sal = sal[idx]
svec = svec[:, idx]
sal = sal**-0.5
sal = np.diagflat(sal)
X = svec @ sal @ svec.T
C_ao2mo = np.linalg.inv(X) @ C
Cocc = C_ao2mo[:, :n_a]
D = Cocc @ Cocc.T
DMO = C_ao2mo.T @ D @ C_ao2mo
#only for cas space
DMO = DMO[cas_nstart:cas_nstop,cas_nstart:cas_nstop]
self.dm_aa = DMO
self.dm_bb = DMO
print("DENSITY")
print(self.dm_aa.shape)
if 0:
h = C.T.dot(mf.get_hcore()).dot(C)
g = ao2mo.kernel(mol,C,aosym='s4',compact=False).reshape(4*((n_orb),))
const,heff = get_eff_for_casci(cas_nstart,cas_nstop,h,g)
print(heff)
print("const",const)
print("ecore",ecore)
idx = range(cas_nstart,cas_nstop)
h = h[:,idx]
h = h[idx,:]
g = g[:,:,:,idx]
g = g[:,:,idx,:]
g = g[:,idx,:,:]
g = g[idx,:,:,:]
self.ecore = const
self.h = h + heff
self.g = g
elif cas==False:
h = C.T.dot(mf.get_hcore()).dot(C)
g = ao2mo.kernel(mol,C,aosym='s4',compact=False).reshape(4*((n_orb),))
print(h)
#return h, g, enu, C,mol,mf
self.h = h
self.g = g
self.ecore = enu
self.mf = mf
self.mol = mol
self.C = C
J,K = mf.get_jk()
self.J = self.C.T @ J @ self.C
self.K = self.C.T @ J @ self.C
#HF density
if orb_basis == 'scf':
D = mf.make_rdm1(mo_coeff=None)
S = mf.get_ovlp()
sal, svec = np.linalg.eigh(S)
idx = sal.argsort()[::-1]
sal = sal[idx]
svec = svec[:, idx]
sal = sal**-0.5
sal = np.diagflat(sal)
X = svec @ sal @ svec.T
C_ao2mo = np.linalg.inv(X) @ C
Cocc = C_ao2mo[:, :n_a]
D = Cocc @ Cocc.T
DMO = C_ao2mo.T @ D @ C_ao2mo
self.dm_aa = DMO
self.dm_bb = DMO
print("DENSITY")
print(self.dm_aa)
print("Find Fermi-Orbitals for spin: {0} / {1} electrons".format(
_mys, te))
#print(" total e: {0} (spin {1})".format(te,spin))
#print("1s core: {0}".format(ne_1s))
#print("valence: {0}".format(ve))
# define which orbitals are use for initial boys
pz_idx = np.arange(0, te)
nfods = len(pz_idx)
initial_fods = np.zeros((nfods, 3), dtype=np.float64)
#print(pz_idx, len(pz_idx))
#sys.exit()
# build the localized orbitals
loc_orb = lo.Boys(mol, m.mo_coeff[spin][:, pz_idx]).kernel()
#print loc_orb.shape
osym = 'X'
if spin == 1:
osym = 'He'
for j in range(pz_idx.shape[0]):
sstr = 'UP'
if spin == 1:
sstr = 'DN'
print(" density fit for spin {0} orb #{1} ...".format(
sstr, j + 1),
flush=True)
#print("find initial fod: {0}".format(j))
initial_fods[j, :] = lorb2fod(m,
loc_orb[:, j],
def init_pyscf(molecule, charge, spin, basis, orbitals):
# {{{
#PYSCF inputs
print(" ---------------------------------------------------------")
print(" ")
print(" Using Pyscf:")
print(" ")
print(" ---------------------------------------------------------")
print(" ")
mol = gto.Mole()
mol.atom = molecule
# this is needed to prevent openblas - openmp clash for some reason
# todo: take out
lib.num_threads(1)
mol.max_memory = 1000 # MB
mol.charge = charge
mol.spin = spin
mol.basis = basis
mol.build()
#orbitals and electrons
n_orb = mol.nao_nr()
n_b, n_a = mol.nelec
nel = n_a + n_b
#SCF
mf = scf.RHF(mol).run()
#mf = scf.ROHF(mol).run()
C = mf.mo_coeff #MO coeffs
S = mf.get_ovlp()
print(" Orbs1:")
print(C)
Cl = cp.deepcopy(C)
if orbitals == "boys":
print("\nUsing Boys localised orbitals:\n")
cl_o = lo.Boys(mol, mf.mo_coeff[:, :n_a]).kernel(verbose=4)
cl_v = lo.Boys(mol, mf.mo_coeff[:, n_a:]).kernel(verbose=4)
Cl = np.column_stack((cl_o, cl_v))
elif orbitals == "pipek":
print("\nUsing Pipek-Mezey localised orbitals:\n")
cl_o = lo.PM(mol, mf.mo_coeff[:, :n_a]).kernel(verbose=4)
cl_v = lo.PM(mol, mf.mo_coeff[:, n_a:]).kernel(verbose=4)
Cl = np.column_stack((cl_o, cl_v))
elif orbitals == "edmiston":
print("\nUsing Edmiston-Ruedenberg localised orbitals:\n")
cl_o = lo.ER(mol, mf.mo_coeff[:, :n_a]).kernel(verbose=4)
cl_v = lo.ER(mol, mf.mo_coeff[:, n_a:]).kernel(verbose=4)
Cl = np.column_stack((cl_o, cl_v))
# elif orbitals == "svd":
# print("\nUsing SVD localised orbitals:\n")
# cl_o = cp.deepcopy(mf.mo_coeff[:,:n_a])
# cl_v = cp.deepcopy(mf.mo_coeff[:,n_a:])
#
# [U,s,V] = np.linalg.svd(cl_o)
# cl_o = cl_o.dot(V.T)
# Cl = np.column_stack((cl_o,cl_v))
elif orbitals == "canonical":
print("\nUsing Canonical orbitals:\n")
pass
else:
print("Error: Wrong orbital specification:")
exit()
print(" Overlap:")
print(C.T.dot(S).dot(Cl))
# sort by cluster
blocks = [[0, 1, 2, 3], [4, 5, 6, 7]]
O = Cl[:, :n_a]
V = Cl[:, n_a:]
[sorted_order, cluster_sizes] = mulliken_clustering(blocks, mol, O)
O = O[:, sorted_order]
[sorted_order, cluster_sizes] = mulliken_clustering(blocks, mol, V)
V = V[:, sorted_order]
Cl = np.column_stack((O, V))
C = cp.deepcopy(Cl)
# dump orbitals for viewing
molden.from_mo(mol, 'orbitals_canon.molden', C)
molden.from_mo(mol, 'orbitals_local.molden', Cl)
##READING INTEGRALS FROM PYSCF
E_nu = gto.Mole.energy_nuc(mol)
T = mol.intor('int1e_kin_sph')
V = mol.intor('int1e_nuc_sph')
hcore = T + V
S = mol.intor('int1e_ovlp_sph')
g = mol.intor('int2e_sph')
print("\nSystem and Method:")
print(mol.atom)
print("Basis set :%12s" % (mol.basis))
print("Number of Orbitals :%10i" % (n_orb))
print("Number of electrons :%10i" % (nel))
print("Nuclear Repulsion :%16.10f " % E_nu)
print("Electronic SCF energy :%16.10f " %
(mf.e_tot - E_nu))
print("SCF Energy :%16.10f" %
(mf.e_tot))
print(" AO->MO")
g = np.einsum("pqrs,pl->lqrs", g, C)
g = np.einsum("lqrs,qm->lmrs", g, C)
g = np.einsum("lmrs,rn->lmns", g, C)
g = np.einsum("lmns,so->lmno", g, C)
h = reduce(np.dot, (C.conj().T, hcore, C))
# #mf = mf.density_fit(auxbasis='weigend')
# #mf._eri = None
# mcc = cc.UCCSD(mf)
# eris = mcc.ao2mo()
# eris.g = g
# eris.focka = h
# eris.fockb = h
#
# emp2, t1, t2 = mcc.init_amps(eris)
# exit()
# print(abs(t2).sum() - 4.9318753386922278)
# print(emp2 - -0.20401737899811551)
# t1, t2 = update_amps(mcc, t1, t2, eris)
# print(abs(t1).sum() - 0.046961325647584914)
# print(abs(t2).sum() - 5.378260578551683 )
#
#
# exit()
return (n_orb, n_a, n_b, h, g, mol, E_nu, mf.e_tot, C, S)
def hl_solver (self, chempot=0., threshold=1.0e-12):
# energy = self.mol.energy_nuc()
energy = 0.
nelec = 0.
rdm_ao = np.dot(self.cf, self.cf.T)
AX_val = np.dot(self.Sf, self.A_val)
rdm_val = np.dot(AX_val.T, np.dot(rdm_ao, AX_val))
print ( "shapes" )
print ( "cf",self.cf.shape )
print ( "rdm_ao",rdm_ao.shape )
print ( "AX_val",AX_val.shape )
print ( "rdm_val",rdm_val.shape )
if(not self.parallel):
myrange = range(self.nimp)
else:
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = MPI.COMM_WORLD.Get_rank()
size = MPI.COMM_WORLD.Get_size()
myrange = range(rank,rank+1)
for i in myrange:
# prepare orbital indexing
imp_val = np.zeros((self.nvl,), dtype=bool)
imp_val_ = np.zeros((self.nvl,), dtype=bool)
if self.nc > 0:
imp_core = np.zeros((self.nc,), dtype=bool)
imp_core_ = np.zeros((self.nc,), dtype=bool)
if self.nvt > 0:
imp_virt = np.zeros((self.nvt,), dtype=bool)
imp_virt_ = np.zeros((self.nvt,), dtype=bool)
for k in range(self.mol.natm):
if self.imp_atx[i][k]:
imp_val[self.at_val == k] = True
if self.nc > 0:
imp_core[self.at_core == k] = True
if self.nvt > 0:
imp_virt[self.at_virt == k] = True
if self.imp_at[i][k]:
imp_val_[self.at_val == k] = True
if self.nc > 0:
imp_core_[self.at_core == k] = True
if self.nvt > 0:
imp_virt_[self.at_virt == k] = True
print("imp val", imp_val)
# embedding
cf_tmp, ncore, nact, ImpOrbs_x = \
embedding.embedding (rdm_val, imp_val, \
threshold=self.thresh, \
transform_imp='hf')
print("Doing EMBEDDING")
print("cf_tmp", cf_tmp)
print("ncore, nact", ncore, nact)
print("ImpOrbs_x", ImpOrbs_x)
cf_tmp = np.dot(self.A_val, cf_tmp)
print("cf_tmp", cf_tmp)
# localize imp+bath orbitals
if self.method == 'dmrg':
XR = np.random.rand(nact,nact)
XR -= XR.T
XS = sla.expm(0.01*XR)
cf_ib = np.dot(cf_tmp[:,ncore:ncore+nact], XS)
# loc = localizer.localizer (self.mol, cf_ib, 'boys')
# loc.verbose = 5
# cf_ib = loc.optimize(threshold=1.0e-5)
# del loc
cf_ib = lo.Boys(mol, cd_ib).kernel()
R = np.dot(cf_ib.T, \
np.dot(self.Sf, cf_tmp[:,ncore:ncore+nact]))
print ( np.allclose(np.dot(cf_tmp[:,ncore:ncore+nact], \
ImpOrbs_x), \
np.dot(cf_ib, np.dot(R, ImpOrbs_x))) )
ImpOrbs_x = np.dot(R, ImpOrbs_x)
cf_tmp[:,ncore:ncore+nact] = cf_ib
print ( cf_ib )
# prepare ImpOrbs
ni_val = nact
nj_val = np.count_nonzero(imp_val_)
if self.nc > 0:
ni_core = np.count_nonzero(imp_core)
nj_core = np.count_nonzero(imp_core_)
else:
ni_core = nj_core = 0
if self.nvt > 0:
ni_virt = np.count_nonzero(imp_virt)
nj_virt = np.count_nonzero(imp_virt_)
else:
ni_virt = nj_virt = 0
ii = 0
ImpOrbs = np.zeros((ni_val+ni_core+ni_virt,\
nj_val+nj_core+nj_virt,))
if self.nc > 0:
j = 0
for i in range(self.nc):
if imp_core[i] and imp_core_[i]:
ImpOrbs[j,ii] = 1.
ii += 1
if imp_core[i]:
j += 1
j = 0
for i in range(self.nvl):
if imp_val[i] and imp_val_[i]:
ImpOrbs[ni_core:ni_core+ni_val,ii] = ImpOrbs_x[:,j]
ii += 1
if imp_val[i]:
j += 1
if self.nvt > 0:
j = 0
for i in range(self.nvt):
if imp_virt[i] and imp_virt_[i]:
ImpOrbs[ni_core+ni_val+j,ii] = 1.
ii += 1
if imp_virt[i]:
j += 1
# prepare orbitals
cf_core = cf_virt = None
if self.nc > 0:
cf_core = self.A_core[:,imp_core]
if self.nvt > 0:
cf_virt = self.A_virt[:,imp_virt]
cf_val = cf_tmp[:,ncore:ncore+nact]
if cf_core is not None and cf_virt is not None:
cf = np.hstack ((cf_core, cf_val, cf_virt,))
elif cf_core is not None:
cf = np.hstack ((cf_core, cf_val,))
elif cf_virt is not None:
cf = np.hstack ((cf_val, cf_virt,))
else:
cf = cf_val
# prepare core
if self.nc > 0:
Ac_ = self.A_core[:,~(imp_core)]
X_core = np.hstack((Ac_, cf_tmp[:,:ncore],))
else:
X_core = cf_tmp[:,:ncore]
n_orth = cf.shape[1]
if cf_virt is not None:
n_orth -= cf_virt.shape[1]
print("x-core", X_core)
print("cf b4 solver", cf)
print("imporbs", ImpOrbs)
if self.method == 'hf':
nel_, en_ = \
pyscf_hf.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth)
elif self.method == 'cc':
nel_, en_ = \
pyscf_cc.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot)
elif self.method == 'ccsd(t)':
nel_, en_ = \
pyscf_ccsdt.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth)
elif self.method == 'mp2':
nel_, en_ = \
pyscf_mp2.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot)
elif self.method == 'dfmp2':
nel_, en_ = \
pyscf_dfmp2.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot, mf_tot=self.mf_tot)
elif self.method == 'dfmp2_testing':
nel_, en_ = \
dfmp2_testing.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot, mf_tot=self.mf_tot)
elif self.method == 'dfmp2_testing2':
# print(self.mol)
# print(2*(self.nup-X_core.shape[1]))
# print(X_core.shape)
# print(cf.shape)
# print(ImpOrbs.shape)
# print(n_orth)
nel_, en_ = \
dfmp2_testing2.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot ) #, mf_tot=self.mf_tot)
elif self.method == 'dfmp2_testing3':
nel_, en_ = \
dfmp2_testing3.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot, mf_tot=self.mf_tot)
elif self.method == 'dfmp2_testing4':
nel_, en_ = \
dfmp2_testing4.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth,FrozenPot=self.FrozenPot, mf_tot=self.mf_tot)
elif self.method == 'fci':
nel_, en_ = \
pyscf_fci.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth)
elif self.method == 'dmrg':
nel_, en_ = \
dmrg.solve (self.mol, \
2*(self.nup-X_core.shape[1]), \
X_core, cf, ImpOrbs, chempot=chempot, \
n_orth=n_orth)
nelec += nel_
energy += en_
if(self.parallel):
nelec_tot = comm.reduce(nelec, op=MPI.SUM,root=0)
energy_tot = comm.reduce(energy,op=MPI.SUM,root=0)
if(rank==0):
energy_tot += self.mol.energy_nuc()+self.e_core
nelec = comm.bcast(nelec_tot, root=0)
energy = comm.bcast(energy_tot,root=0)
comm.barrier()
if(rank==0): print ( 'DMET energy = ', energy )
else:
energy+=self.mol.energy_nuc()+self.e_core
print ( 'DMET energy = ', energy )
return nelec
#!/usr/bin/env python import numpy from pyscf import scf, gto, lo from pyscf.tools import molden mol = gto.Mole() mol.basis = 'cc-pvdz' mol.atom = ''' O H 1 1.1 H 1 1.1 2 104 ''' mol.charge = 0 mol.spin = 0 mol.symmetry = 1 mol.verbose = 4 mol.build() mf = scf.RHF(mol) mf.kernel() occ = mf.mo_coeff[:,mf.mo_occ>0] vir = mf.mo_coeff[:,mf.mo_occ==0] loc_occ = lo.ER(mol, occ).kernel() loc_vir = lo.Boys(mol, vir).kernel()