def get_orb_sym(self):
mo = symm.symmetrize_orb(self.mol, self.mo_coeff)
self.orb_sym = symm.label_orb_symm(self.mol, self.mol.irrep_id, self.mol.symm_orb, mo)
if self.nfo > 0:
self.orb_sym = self.orb_sym[self.nfo:]
self.transform_orb_sym()
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 kernel(self, mo_coeff=None, ci0=None, macro=None, micro=None, callback=None, _kern=None):
if mo_coeff is None:
mo_coeff = self.mo_coeff
else:
self.mo_coeff = mo_coeff
if macro is None:
macro = self.max_cycle_macro
if micro is None:
micro = self.max_cycle_micro
if callback is None:
callback = self.callback
if _kern is None:
_kern = mc1step.kernel
if self.verbose > logger.QUIET:
pyscf.gto.mole.check_sanity(self, self._keys, self.stdout)
self.mol.check_sanity(self)
self.dump_flags()
# irrep_name = self.mol.irrep_name
irrep_name = self.mol.irrep_id
try:
self.orbsym = symm.label_orb_symm(self.mol, irrep_name, self.mol.symm_orb, mo_coeff, s=self._scf.get_ovlp())
except ValueError:
logger.warn(self, "mc1step_symm symmetrizes input orbitals")
s = self._scf.get_ovlp()
mo_coeff = symm.symmetrize_orb(self.mol, mo_coeff, s=s)
diag = numpy.einsum("ki,ki->i", mo_coeff, numpy.dot(s, mo_coeff))
mo_coeff = numpy.einsum("ki,i->ki", mo_coeff, 1 / numpy.sqrt(diag))
self.orbsym = symm.label_orb_symm(self.mol, irrep_name, self.mol.symm_orb, mo_coeff, s=s)
if not hasattr(self.fcisolver, "orbsym") or not self.fcisolver.orbsym:
ncore = self.ncore
nocc = self.ncore + self.ncas
self.fcisolver.orbsym = self.orbsym[ncore:nocc]
logger.debug(self, "Active space irreps %s", str(self.fcisolver.orbsym))
self.converged, self.e_tot, e_cas, self.ci, self.mo_coeff = _kern(
self,
mo_coeff,
tol=self.conv_tol,
conv_tol_grad=self.conv_tol_grad,
macro=macro,
micro=micro,
ci0=ci0,
callback=callback,
verbose=self.verbose,
)
logger.note(self, "CASSCF energy = %.15g", self.e_tot)
return self.e_tot, e_cas, self.ci, self.mo_coeff
def test_1():
np.set_printoptions(suppress=True, precision=2, linewidth=1500)
pyscf.lib.num_threads(
1) #with degenerate states and multiple processors there can be issues
### PYSCF INPUT
r0 = 1.2
molecule = '''
N 0 0 0
N 0 0 {}
'''.format(r0)
charge = 0
spin = 0
basis_set = '6-31g'
### TPSCI BASIS INPUT
orb_basis = 'scf'
if basis_set == '6-31g':
cas = True
cas_nstart = 2
cas_nstop = 18
cas_nel = 10
### TPSCI CLUSTER INPUT
init_fspace = ((2, 2), (1, 1), (1, 1), (1, 1))
blocks = [range(0, 4), range(4, 8), range(8, 12), range(12, 16)]
if basis_set == 'ccpvdz':
cas = True
cas_nstart = 2
cas_nstop = 28
cas_nel = 10
### TPSCI CLUSTER INPUT
init_fspace = ((2, 2), (1, 1), (1, 1), (1, 1), (0, 0))
blocks = [
range(0, 4),
range(4, 10),
range(10, 16),
range(16, 22),
range(22, 26)
]
nelec = tuple([sum(x) for x in zip(*init_fspace)])
if cas == True:
assert (cas_nel == sum(nelec))
nelec = cas_nel
#Integrals from pyscf
pmol = PyscfHelper()
pmol.init(molecule,
charge,
spin,
basis_set,
orb_basis,
cas_nstart=cas_nstart,
cas_nstop=cas_nstop,
cas_nel=cas_nel,
cas=True)
h = pmol.h
g = pmol.g
ecore = pmol.ecore
print("Ecore:%16.8f" % ecore)
C = pmol.C
K = pmol.K
mol = pmol.mol
mo_energy = pmol.mf.mo_energy
dm_aa = pmol.dm_aa
dm_bb = pmol.dm_bb
#clustering for cr (pairing type)
idx = ordering_diatomics(mol, C, basis_set)
h, g = reorder_integrals(idx, h, g)
C = C[:, idx]
mo_energy = mo_energy[idx]
dm_aa = dm_aa[:, idx]
dm_aa = dm_aa[idx, :]
dm_bb = dm_bb[:, idx]
dm_bb = dm_bb[idx, :]
print(dm_aa)
print(h)
from pyscf import molden
#molden.from_mo(pmol.mol, 'h8.molden', C)
print(h)
mol = pmol.mol
if mol.symmetry == True:
from pyscf import symm
mo = symm.symmetrize_orb(mol, C)
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]))
clusters, clustered_ham, ci_vector, cmf_out = system_setup(h,
g,
ecore,
blocks,
init_fspace,
cmf_maxiter=0)
energy1, t, rmda, rdmb = cmf(clustered_ham,
ci_vector,
h,
g,
max_iter=50,
dm_guess=(dm_aa, dm_bb),
diis=True)
energy2, t, rdma, rdmb = cmf(clustered_ham,
ci_vector,
h,
g,
max_iter=50,
dm_guess=None,
diis=False)
assert (np.abs(energy1 - energy2) < 1e-6)
#idx = e1_order(h,1e-2)
idx = ordering_diatomics(mol, C, basis_set=basis_set)
norb = cas_nstop - cas_nstart
h, g = reorder_integrals(idx, h, g)
C = C[:, idx]
mo_energy = mo_energy[idx]
dm_aa = dm_aa[:, idx]
dm_aa = dm_aa[idx, :]
dm_bb = dm_bb[:, idx]
dm_bb = dm_bb[idx, :]
print(h)
print(dm_aa)
from pyscf import symm
mo = symm.symmetrize_orb(mol, C)
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, osym[i], mo_energy[i]))
print("r:", r0)
print(h)
if do_tci:
oocmf = CmfSolver(h, g, ecore, blocks, init_fspace, C, max_roots=100)
oocmf.init((dm_aa, dm_bb))
oo = False
if oo:
from scipy import optimize
def test_1():
### PYSCF INPUT
r0 = 1.40
molecule = '''
H 0.00 0.00 0.00
H 1.23 0.00 0.00
H 1.23 0.00 {0}
H 0.00 0.00 {0}'''.format(r0)
charge = 0
spin = 0
basis_set = '6-31g'
### TPSCI BASIS INPUT
orb_basis = 'lowdin'
cas = False
cas_nstart = 0
cas_nstop = 8
cas_nel = 4
### TPSCI CLUSTER INPUT
blocks = [[0, 1, 2, 3], [4, 5, 6, 7]]
init_fspace = ((1, 1), (1, 1))
nelec = tuple([sum(x) for x in zip(*init_fspace)])
if cas == True:
assert (cas_nel == sum(nelec))
nelec = cas_nel
# Integrals from pyscf
#Integrals from pyscf
pmol = PyscfHelper()
pmol.init(molecule,
charge,
spin,
basis_set,
orb_basis,
cas=False,
cas_nstart=cas_nstart,
cas_nstop=cas_nstop,
cas_nel=cas_nel)
#loc_nstart=loc_start,loc_nstop = loc_stop)
C = pmol.C
h = pmol.h
g = pmol.g
ecore = pmol.ecore
print("Ecore:%16.8f" % ecore)
mol = pmol.mol
mf = pmol.mf
mo_energy = mf.mo_energy[cas_nstart:cas_nstop]
from pyscf import symm
mo = symm.symmetrize_orb(mol, C)
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]))
from pyscf import molden
molden.from_mo(mol, 'h8.molden', C)
# Initialize the CMF solver.
n_blocks = len(blocks)
clusters = [Cluster(ci, c) for ci, c in enumerate(blocks)]
print(" Ecore :%16.8f" % ecore)
print(" Clusters:")
[print(ci) for ci in clusters]
clustered_ham = ClusteredOperator(clusters, core_energy=ecore)
print(" Add 1-body terms")
clustered_ham.add_local_terms()
clustered_ham.add_1b_terms(h)
print(" Add 2-body terms")
clustered_ham.add_2b_terms(g)
ci_vector = ClusteredState()
ci_vector.init(clusters, init_fspace)
Ecmf, converged, rdm_a, rdm_b = cmf(clustered_ham,
ci_vector,
h,
g,
max_iter=20)
ecmf = Ecmf + ecore
for ci_idx, ci in enumerate(clusters):
ci.form_fockspace_eigbasis(h,
g, [init_fspace[ci_idx]],
max_roots=10,
rdm1_a=rdm_a,
rdm1_b=rdm_b,
iprint=1)
print(" Build new operators for cluster ", ci.idx)
ci.build_op_matrices(iprint=0)
ci.build_local_terms(h, g)
emp2, pt_vector = compute_pt2_correction(ci_vector,
clustered_ham,
Ecmf,
thresh_asci=0,
thresh_search=1e-9,
pt_type='mp',
nbody_limit=4,
matvec=1)
e1, _ = truncated_pt2(clustered_ham, ci_vector, pt_vector, method='mp2')
assert (abs(e1 - emp2) < 1e-12)
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()
mf = scf.RHF(mol).run(conv_tol=1e-14,max_cycle=200)
#C = mf.mo_coeff #MO coeffs
enu = mf.energy_nuc()
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]))
mo_occ = mf.mo_occ>0
mo_vir = mf.mo_occ==0
print(mo_occ)
print(mo_vir)
mo_occ = np.where(mf.mo_occ>0)[0]
mo_vir = np.where(mf.mo_occ==0)[0]
print(mo_occ)
print(mo_vir)
from pyscf import mo_mapping
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)
def run():
### PYSCF INPUT
r0 = 1.50
molecule = '''
Cr
Cr 1 {}
'''.format(r0)
charge = 0
spin = 0
basis_set = 'def2-svp'
### TPSCI BASIS INPUT
orb_basis = 'scf'
cas = True
cas_nstart = 12
cas_nstop = 42
loc_start = 1
loc_stop = 6
cas_nel = 24
def ordering_diatomics_cr(mol, C):
# {{{
##DZ basis diatomics reordering with frozen 1s
orb_type = ['s', 'pz', 'dz', 'px', 'dxz', 'py', 'dyz', 'dx2-y2', 'dxy']
ref = np.zeros(C.shape[1])
## Find dimension of each space
dim_orb = []
for orb in orb_type:
print("Orb type", orb)
idx = 0
for label in mol.ao_labels():
if orb in label:
#print(label)
idx += 1
##frozen 1s orbitals
if orb == 's':
idx -= 6
elif orb == 'px':
idx -= 2
elif orb == 'py':
idx -= 2
elif orb == 'pz':
idx -= 2
dim_orb.append(idx)
print(idx)
new_idx = []
## Find orbitals corresponding to each orb space
for i, orb in enumerate(orb_type):
print("Orbital type:", orb)
from pyscf import mo_mapping
s_pop = mo_mapping.mo_comps(orb, mol, C)
print(s_pop)
ref += s_pop
cas_list = s_pop.argsort()[-dim_orb[i]:]
print('cas_list', np.array(cas_list))
new_idx.extend(cas_list)
#print(orb,' population for active space orbitals', s_pop[cas_list])
ao_labels = mol.ao_labels()
#idx = mol.search_ao_label(['N.*s'])
#for i in idx:
# print(i, ao_labels[i])
print(ref)
print(new_idx)
for label in mol.ao_labels():
print(label)
return new_idx
# }}}
# basis is SVP read comments by alex thom paper DOI:10.1021/acs.jctc.9b01023
from pyscf import gto
basis_set = {
'Cr':
gto.parse('''
BASIS "ao basis" PRINT
#BASIS SET: (14s,8p,5d) -> [5s,2p,2d]
Cr S
51528.086349 0.14405823106E-02
7737.2103487 0.11036202287E-01
1760.3748470 0.54676651806E-01
496.87706544 0.18965038103
161.46520598 0.38295412850
55.466352268 0.29090050668
Cr S
107.54732999 -0.10932281100
12.408671897 0.64472599471
5.0423628826 0.46262712560
Cr S
8.5461640165 -0.22711013286
1.3900441221 0.73301527591
0.56066602876 0.44225565433
Cr S
0.71483705972E-01 1.0000000000
Cr S
0.28250687604E-01 1.0000000000
Cr P
640.48536096 0.96126715203E-02
150.69711194 0.70889834655E-01
47.503755296 0.27065258990
16.934120165 0.52437343414
6.2409680590 0.34107994714
Cr P
3.0885463206 0.33973986903
1.1791047769 0.57272062927
0.43369774432 0.24582728206
Cr D
27.559479426 0.30612488044E-01
7.4687020327 0.15593270944
2.4345903574 0.36984421276
0.78244754808 0.47071118077
Cr D
0.21995774311 0.33941649889
END''')
}
### TPSCI CLUSTER INPUT
init_fspace = ((1, 1), (3, 3), (3, 3), (3, 3), (1, 1), (1, 1))
blocks = [
range(0, 4),
range(4, 10),
range(10, 16),
range(16, 22),
range(22, 26),
range(26, 30)
]
# Integrals from pyscf
#Integrals from pyscf
pmol = PyscfHelper()
pmol.init(molecule,
charge,
spin,
basis_set,
orb_basis,
cas_nstart=cas_nstart,
cas_nstop=cas_nstop,
cas_nel=cas_nel,
cas=True,
loc_nstart=loc_start,
loc_nstop=loc_stop)
h = pmol.h
g = pmol.g
ecore = pmol.ecore
print("Ecore:%16.8f" % ecore)
C = pmol.C
K = pmol.K
mol = pmol.mol
mo_energy = pmol.mf.mo_energy
dm_aa = pmol.dm_aa
dm_bb = pmol.dm_bb
do_tci = 1
#cluster using hcore
idx = ordering_diatomics_cr(mol, C)
h, g = reorder_integrals(idx, h, g)
C = C[:, idx]
mo_energy = mo_energy[idx]
dm_aa = dm_aa[:, idx]
dm_aa = dm_aa[idx, :]
dm_bb = dm_bb[:, idx]
dm_bb = dm_bb[idx, :]
print(dm_aa)
from pyscf import molden
molden.from_mo(pmol.mol, 'h8.molden', C)
print(h)
mol = pmol.mol
if mol.symmetry == True:
from pyscf import symm
mo = symm.symmetrize_orb(mol, C)
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]))
clusters, clustered_ham, ci_vector = system_setup(h,
g,
ecore,
blocks,
init_fspace,
cmf_maxiter=20,
cmf_dm_guess=(dm_aa,
dm_bb),
cmf_diis=True,
max_roots=100,
delta_elec=3)
ndata = 0
for ci in clusters:
for o in ci.ops:
for f in ci.ops[o]:
ndata += ci.ops[o][f].size * ci.ops[o][f].itemsize
print(" Amount of data stored in TDMs: %12.2f Gb" % (ndata * 1e-9))
init_fspace = ((1, 1), (3, 3), (3, 3), (3, 3), (1, 1), (1, 1))
ci_vector, pt_vector, etci, etci2, t_conv = bc_cipsi_tucker(
ci_vector.copy(),
clustered_ham,
pt_type='mp',
thresh_cipsi=1e-3,
thresh_ci_clip=1e-6,
max_tucker_iter=4,
nbody_limit=4,
thresh_search=1e-3,
thresh_asci=1e-2,
tucker_state_clip=100, #don't use any pt for tucker
tucker_conv_target=0, #converge variational energy
nproc=None)
ci_vector, pt_vector, etci, etci2, t_conv = bc_cipsi_tucker(
ci_vector.copy(),
clustered_ham,
pt_type='mp',
thresh_cipsi=1e-5,
thresh_ci_clip=1e-7,
max_tucker_iter=2,
nbody_limit=4,
thresh_search=1e-4,
thresh_asci=1e-2,
tucker_state_clip=100, #don't use any pt for tucker
tucker_conv_target=0, #converge variational energy
nproc=None)
ci_vector, pt_vector, etci, etci2, t_conv = bc_cipsi_tucker(
ci_vector.copy(),
clustered_ham,
pt_type='mp',
thresh_cipsi=1e-6,
thresh_ci_clip=1e-8,
max_tucker_iter=2,
nbody_limit=4,
thresh_search=1e-4,
thresh_asci=1e-2,
tucker_state_clip=100, #don't use any pt for tucker
tucker_conv_target=0, #converge variational energy
nproc=None)
ci_vector, pt_vector, etci, etci2, t_conv = bc_cipsi_tucker(
ci_vector.copy(),
clustered_ham,
pt_type='mp',
thresh_cipsi=1e-7,
thresh_ci_clip=1e-9,
max_tucker_iter=4,
nbody_limit=4,
thresh_search=1e-4,
thresh_asci=1e-2,
tucker_state_clip=100, #don't use any pt for tucker
tucker_conv_target=0, #converge variational energy
nproc=None)
tci_dim = len(ci_vector)
ci_vector.print()
ecore = clustered_ham.core_energy
etci += ecore
etci2 += ecore
print(" TCI: %12.9f Dim:%6d" % (etci, tci_dim))
def generate_hamiltonian():
### PYSCF INPUT
r0 = 1.50
molecule = '''
Cr
Cr 1 {}
'''.format(r0)
charge = 0
spin = 0
basis_set = 'def2-svp'
### TPSCI BASIS INPUT
orb_basis = 'scf'
cas = True
cas_nstart = 12
cas_nstop = 42
loc_start = 1
loc_stop = 6
cas_nel = 24
def ordering_diatomics_cr(mol,C):
# {{{
##DZ basis diatomics reordering with frozen 1s
orb_type = ['s','pz','dz','px','dxz','py','dyz','dx2-y2','dxy']
ref = np.zeros(C.shape[1])
## Find dimension of each space
dim_orb = []
for orb in orb_type:
print("Orb type",orb)
idx = 0
for label in mol.ao_labels():
if orb in label:
#print(label)
idx += 1
##frozen 1s orbitals
if orb == 's':
idx -= 6
elif orb == 'px':
idx -=2
elif orb == 'py':
idx -=2
elif orb == 'pz':
idx -=2
dim_orb.append(idx)
print(idx)
new_idx = []
## Find orbitals corresponding to each orb space
for i,orb in enumerate(orb_type):
print("Orbital type:",orb)
from pyscf import mo_mapping
s_pop = mo_mapping.mo_comps(orb, mol, C)
print(s_pop)
ref += s_pop
cas_list = s_pop.argsort()[-dim_orb[i]:]
print('cas_list', np.array(cas_list))
new_idx.extend(cas_list)
#print(orb,' population for active space orbitals', s_pop[cas_list])
ao_labels = mol.ao_labels()
#idx = mol.search_ao_label(['N.*s'])
#for i in idx:
# print(i, ao_labels[i])
print(ref)
print(new_idx)
for label in mol.ao_labels():
print(label)
return new_idx
# }}}
# basis is SVP read comments by alex thom paper DOI:10.1021/acs.jctc.9b01023
from pyscf import gto
basis_set={'Cr': gto.parse('''
BASIS "ao basis" PRINT
#BASIS SET: (14s,8p,5d) -> [5s,2p,2d]
Cr S
51528.086349 0.14405823106E-02
7737.2103487 0.11036202287E-01
1760.3748470 0.54676651806E-01
496.87706544 0.18965038103
161.46520598 0.38295412850
55.466352268 0.29090050668
Cr S
107.54732999 -0.10932281100
12.408671897 0.64472599471
5.0423628826 0.46262712560
Cr S
8.5461640165 -0.22711013286
1.3900441221 0.73301527591
0.56066602876 0.44225565433
Cr S
0.71483705972E-01 1.0000000000
Cr S
0.28250687604E-01 1.0000000000
Cr P
640.48536096 0.96126715203E-02
150.69711194 0.70889834655E-01
47.503755296 0.27065258990
16.934120165 0.52437343414
6.2409680590 0.34107994714
Cr P
3.0885463206 0.33973986903
1.1791047769 0.57272062927
0.43369774432 0.24582728206
Cr D
27.559479426 0.30612488044E-01
7.4687020327 0.15593270944
2.4345903574 0.36984421276
0.78244754808 0.47071118077
Cr D
0.21995774311 0.33941649889
END''')}
### TPSCI CLUSTER INPUT
init_fspace = ((1, 1),(3, 3),(3, 3),(3, 3), (1, 1), (1, 1))
blocks = [range(0,4),range(4,10),range(10,16),range(16,22),range(22,26),range(26,30)]
# Integrals from pyscf
#Integrals from pyscf
pmol = PyscfHelper()
pmol.init(molecule,charge,spin,basis_set,orb_basis,
cas_nstart=cas_nstart,cas_nstop=cas_nstop,cas_nel=cas_nel,cas=True,
loc_nstart=loc_start,loc_nstop = loc_stop)
h = pmol.h
g = pmol.g
ecore = pmol.ecore
print("Ecore:%16.8f"%ecore)
C = pmol.C
K = pmol.K
mol = pmol.mol
mo_energy = pmol.mf.mo_energy
dm_aa = pmol.dm_aa
dm_bb = pmol.dm_bb
do_fci = 0
do_hci = 0
do_tci = 1
if do_fci:
efci, fci_dim = run_fci_pyscf(h,g,nelec,ecore=ecore)
if do_hci:
ehci, hci_dim = run_hci_pyscf(h,g,nelec,ecore=ecore,select_cutoff=5e-4,ci_cutoff=5e-4)
#cluster using hcore
idx = ordering_diatomics_cr(mol,C)
h,g = reorder_integrals(idx,h,g)
C = C[:,idx]
mo_energy = mo_energy[idx]
dm_aa = dm_aa[:,idx]
dm_aa = dm_aa[idx,:]
dm_bb = dm_bb[:,idx]
dm_bb = dm_bb[idx,:]
print(dm_aa)
from pyscf import molden
molden.from_mo(pmol.mol, 'h8.molden', C)
print(h)
mol = pmol.mol
if mol.symmetry == True:
from pyscf import symm
mo = symm.symmetrize_orb(mol, C)
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]))
clusters = []
for ci,c in enumerate(blocks):
clusters.append(Cluster(ci,c))
print(" Clusters:")
[print(ci) for ci in clusters]
clustered_ham = ClusteredOperator(clusters, core_energy=ecore)
print(" Add 1-body terms")
clustered_ham.add_local_terms()
clustered_ham.add_1b_terms(h)
print(" Add 2-body terms")
clustered_ham.add_2b_terms(g)
# intial state
ci_vector = ClusteredState(clusters)
ci_vector.init(init_fspace)
ci_vector.print()
# do cmf
do_cmf = 1
if do_cmf:
# Get CMF reference
e_cmf, cmf_conv, rdm_a, rdm_b = cmf(clustered_ham, ci_vector, h, g, max_iter=10, dm_guess=(dm_aa, dm_bb), diis=True)
print(" Final CMF Total Energy %12.8f" %(e_cmf + ecore))
# build cluster basis and operator matrices using CMF optimized density matrices
for ci_idx, ci in enumerate(clusters):
print(ci)
fspaces_i = init_fspace[ci_idx]
delta_e = 2
fspaces_i = ci.possible_fockspaces( delta_elec=(fspaces_i[0], fspaces_i[1], delta_e) )
print()
print(" Form basis by diagonalizing local Hamiltonian for cluster: ",ci_idx)
ci.form_fockspace_eigbasis(h, g, fspaces_i, max_roots=100, rdm1_a=rdm_a, rdm1_b=rdm_b)
print(" Build mats for cluster ",ci.idx)
ci.build_op_matrices()
ci.build_local_terms(h,g)
hamiltonian_file = open('hamiltonian_file', 'wb')
pickle.dump(clustered_ham, hamiltonian_file)
print(" Done.")
def test_1():
### PYSCF INPUT
r0 = 2.0
molecule = '''
C -4.308669 0.197146 0.000000
C 4.308669 -0.197146 0.000000
C -3.110874 -0.411353 0.000000
C 3.110874 0.411353 0.000000
H -4.394907 1.280613 0.000000
H 4.394907 -1.280613 0.000000
H -5.234940 -0.367304 0.000000
H 5.234940 0.367304 0.000000
H -3.069439 -1.500574 0.000000
H 3.069439 1.500574 0.000000
C -1.839087 0.279751 0.000000
C 1.839087 -0.279751 0.000000
C -0.634371 -0.341144 0.000000
C 0.634371 0.341144 0.000000
H -1.871161 1.369551 0.000000
H 1.871161 -1.369551 0.000000
H -0.607249 -1.431263 0.000000
H 0.607249 1.431263 0.000000
'''
charge = 0
spin = 0
basis_set = 'sto-3g'
npoly = 4
na = npoly
nb = npoly
### TPSCI BASIS INPUT
orb_basis = 'PM'
cas_nel = 2*npoly
cas_norb = 2*npoly
#Integrals from pyscf
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
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=1e-14)
#C = mf.mo_coeff #MO coeffs
enu = mf.energy_nuc()
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]))
h,ecore,g,C = get_pi_space(mol,mf,cas_norb,cas_nel,local=True)
print("ecore %16.8f"%ecore)
print("MULLIKEN")
m1 = mulliken_ordering(mol,h.shape[0],C)
ppp = np.column_stack(np.where(m1>.90))
print(ppp)
idx = list(ppp[:,1])
m2 = np.where(m1>.90)
idx = m2[1]
C = C[:,idx]
h,g = reorder_integrals(idx,h,g)
#molden.from_mo(mol, 'cas.molden', C)
blocks = [[0,1,2,3],[4,5],[6,7]]
init_fspace = ((2,2),(1,1),(1,1))
#blocks = [[0,1,2,3],[4,5,6,7]]
#init_fspace = ((2,2),(2,2))
from scipy import optimize
oocmf = CmfSolver(h, g, ecore, blocks, init_fspace,C)
oocmf.init()
x = np.zeros_like(h)
min_options = {'gtol': 1e-8, 'disp':False}
opt_result = scipy.optimize.minimize(oocmf.energy, x, jac=oocmf.grad, method = 'BFGS', options=min_options )
#opt_result = scipy.optimize.minimize(oocmf.energy, x, jac=oocmf.grad, method = 'BFGS', callback=oocmf.callback)
print(opt_result.x)
Kpq = opt_result.x.reshape(h.shape)
print(Kpq)
e_fcmf = oocmf.energy_dps()
oocmf.rotate(Kpq)
e_ocmf = oocmf.energy_dps()
print("Orbital Frozen CMF:%12.8f"%e_fcmf)
print("Orbital Optimized CMF:%12.8f"%e_ocmf)
h = oocmf.h
g = oocmf.g
clustered_ham = oocmf.clustered_ham
ci_vector = oocmf.ci_vector
edps = build_hamiltonian_diagonal(clustered_ham,ci_vector)
print("%16.10f"%edps)
#ref_grad = np.array([[-0., -0., -0., -0., -0.136637, -0.001116, -0.00094, 0.030398],
# [ 0., 0., -0., -0., -0.001116, -0.136637, 0.030398, -0.00094 ],
# [ 0., 0., 0., 0., 0.001942, -0.033806, 0.123316, -0.002399],
# [ 0., 0., -0., -0., -0.033806, 0.001942, -0.002399, 0.123316],
# [ 0.136637, 0.001116, -0.001942, 0.033806, 0., 0., 0., 0. ],
# [ 0.001116, 0.136637, 0.033806, -0.001942, 0., -0., 0., 0. ],
# [ 0.00094, -0.030398, -0.123316, 0.002399, -0., -0., 0., 0. ],
# [-0.030398, 0.00094, 0.002399, -0.123316, -0., -0., 0., 0. ]])
ref_angles= np.array([[ 0., -0., -0., -0., -0.097782, 0.002467, -0.005287, 0.00192 ],
[ 0., -0., -0., -0., 0.002467, -0.097782, 0.00192, -0.005287],
[ 0., 0., 0., 0., -0.002466, -0.123235, 0.155944, -0.004683],
[ 0., 0., -0., 0., -0.123235, -0.002466, -0.004683, 0.155944],
[ 0.097782, -0.002467, 0.002466, 0.123235, 0., 0., -0.002248, 0.581917],
[-0.002467, 0.097782, 0.123235, 0.002466, -0., -0., 0.581917, -0.002248],
[ 0.005287, -0.00192, -0.155944, 0.004683, 0.002248, -0.581917, 0., -0. ],
[-0.00192, 0.005287, 0.004683, -0.155944, -0.581917, 0.002248, 0., 0. ]])
print(Kpq)
print(ref_angles)
try:
assert(np.allclose(Kpq,ref_angles,atol=1e-5))
except:
assert(np.allclose(-1*Kpq,ref_angles,atol=1e-5))
assert(abs(e_fcmf - -8.266997040181 ) <1e-8)
assert(abs(e_ocmf - -8.528879972678 ) <1e-8)