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)