def write_fcidump(system, name='FCIDUMP'): fcidump.from_integrals(name, system.H1[0], system.h2e, system.H1[0].shape[0], system.ne, nuc=system.ecore)
def make_fcidump(self, filename): mo_coeff = self.mf.mo_coeff h1 = reduce(numpy.dot, (mo_coeff.T, self.mf.get_hcore(), mo_coeff)) if self.mf._eri is None: eri = ao2mo.full(self.mol, mo_coeff) else: eri = ao2mo.full(self.mf._eri, mo_coeff) nuc = self.mf.energy_nuc() orbsym = getattr(mo_coeff, 'orbsym', None) if self.symmetry in ('DOOH', 'COOV'): self.writeComplexOrbIntegrals(h1, eri, h1.shape[0], self.n_up + self.n_down, nuc, orbsym, self.partner_orbs) fcidump.from_integrals("FCIDUMP_real_orbs", h1, eri, h1.shape[0], self.mol.nelec, nuc, 0, orbsym) else: orbsym = [sym + 1 for sym in orbsym] fcidump.from_integrals(filename, h1, eri, h1.shape[0], self.mol.nelec, nuc, 0, orbsym, tol=1e-15, float_format=' %.16g')
def test_from_integral(self): tmpfcidump = tempfile.NamedTemporaryFile() h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff)) h2 = ao2mo.full(mf._eri, mf.mo_coeff) fcidump.from_integrals(tmpfcidump.name, h1, h2, h1.shape[0], mol.nelectron, tol=1e-15)
def test_fcidump(self, filename): mo_coeff = self.mf.mo_coeff orbsym = getattr(mo_coeff, 'orbsym', None) mo_coeff = reduce(numpy.dot, (mo_coeff, self.real2complex_coeffs.conj().T)) h1 = reduce(numpy.dot, (mo_coeff.conj().T, self.mf.get_hcore(), mo_coeff)) if self.mf._eri is None: eri = ao2mo.full(self.mol, mo_coeff) else: eri = ao2mo.full(self.mf._eri, mo_coeff) nuc = self.mf.energy_nuc() orbsym = [sym + 1 for sym in orbsym] fcidump.from_integrals(filename, h1, eri, h1.shape[0], self.mol.nelec, nuc, 0, orbsym, tol=1e-15, float_format=' %.16g')
def call_molpro(h1e, eri, mo, nelec, inputstr, log=None): tdir = tempfile.mkdtemp(prefix='tmolpro') inpfile = os.path.join(tdir, 'inputs') open(inpfile, 'w').write(inputstr) write_matrop(os.path.join(tdir,'orb.matrop'), mo) nmo = mo.shape[1] fcidump.from_integrals(os.path.join(tdir, 'fcidump'), h1e, eri, nmo, nelec, 0) # note fcidump and orb.matrop should be put in the runtime dir cmd = ' '.join(('cd', tdir, '&& TMPDIR=`pwd`', MOLPROEXE, inpfile)) rec = commands.getoutput(cmd) if 'fehler' in rec: sys.stderr.write('molpro tempfiles in %s\n'%tdir) raise RuntimeError('molpro fail as:\n' + rec) with open(inpfile+'.out') as fin: dat = fin.read() dat1 = dat.split('\n') es = dat1[-4] if log is not None: log.debug1(dat) log.debug('\n'.join(dat1[-5:-3])) eci, escf = map(float, es.split())[:2] if os.path.isfile(os.path.join(tdir,'rdm1')): with open(os.path.join(tdir,'rdm1')) as fin: fin.readline() fin.readline() dat = fin.read().replace(',', ' ').split() rdm1 = numpy.array(map(float, dat[:-1])).reshape(nmo,nmo) # molpro will transform rdm1 back to AO representation (consistent to fcidump) else: rdm1 = None shutil.rmtree(tdir) return escf, eci, rdm1
def test_from_integral(self): tmpfcidump = tempfile.NamedTemporaryFile(dir=lib.param.TMPDIR) h1 = reduce(numpy.dot, (mf.mo_coeff.T, mf.get_hcore(), mf.mo_coeff)) h2 = ao2mo.full(mf._eri, mf.mo_coeff) fcidump.from_integrals(tmpfcidump.name, h1, h2, h1.shape[0], mol.nelectron, tol=1e-15)
#mol.symmetry = True mol.basis = {'H': 'sto-6g'} mol.build() m = scf.RHF(mol) m.verbose = 4 ehf = m.scf() print "ORB ENERGY : ", m.mo_energy #1-e Integrals hcore = mol.intor('cint1e_nuc_sph') + mol.intor('cint1e_kin_sph') ovlp = mol.intor('cint1e_ovlp_sph') Sihalf = lo.orth.lowdin(ovlp) h1e = np.einsum('pi,pq,qj->ij',Sihalf,hcore,Sihalf) nmo = np.shape(h1e)[0] #2-e Integrals eri_4fold = ao2mo.kernel(mol,Sihalf) #FCI-DUMP fname = 'FCIDUMP' nelec = mol.nelectron energy_nuc = mol.energy_nuc() fcid.from_integrals(fname,h1e,eri_4fold,nmo,nelec,energy_nuc) #Energy Test e = fci.direct_spin0.kernel(h1e,eri_4fold,nmo,nelec) print e[0]+energy_nuc
# # Example 2: Given a set of orbitals to transform integrals then dump the # integrals to FCIDUMP # fcidump.from_mo(mol, 'fcidump.example2', myhf.mo_coeff) # # Exampel 3: FCIDUMP for given 1e and 2e integrals # c = myhf.mo_coeff h1e = reduce(numpy.dot, (c.T, myhf.get_hcore(), c)) eri = ao2mo.kernel(mol, c) fcidump.from_integrals('fcidump.example3', h1e, eri, c.shape[1], mol.nelectron, ms=0) # # Exampel 4: Ignore small matrix elements in FCIDUMP # fcidump.from_integrals('fcidump.example4', h1e, eri, c.shape[1], mol.nelectron, ms=0, tol=1e-10) # # Example 5: Inculde the symmetry information in FCIDUMP # # to write the irreps for each orbital, first use pyscf.symm.label_orb_symm to # get the irrep ids MOLPRO_ID = {'D2h': { 'Ag' : 1, 'B1g': 4, 'B2g': 6,
def solve(mol, nel, cf_core, cf_gs, ImpOrbs, chempot=0., n_orth=0): # cf_core : core orbitals (in AO basis, assumed orthonormal) # cf_gs : guess orbitals (in AO basis) # ImpOrbs : cf_gs -> impurity orbitals transformation # n_orth : number of orthonormal orbitals in cf_gs [1..n_orth] cfx = cf_gs Sf = mol.intor_symmetric('cint1e_ovlp_sph') Hc = mol.intor_symmetric('cint1e_kin_sph') \ + mol.intor_symmetric('cint1e_nuc_sph') # core contributions dm_core = np.dot(cf_core, cf_core.T) * 2 jk_core = scf.hf.get_veff(mol, dm_core) e_core = np.trace(np.dot(Hc, dm_core)) \ + 0.5*np.trace(np.dot(jk_core, dm_core)) # transform integrals Sp = np.dot(cfx.T, np.dot(Sf, cfx)) Hp = np.dot(cfx.T, np.dot(Hc, cfx)) jkp = np.dot(cfx.T, np.dot(jk_core, cfx)) intsp = ao2mo.outcore.full_iofree(mol, cfx) # orthogonalize cf [virtuals] cf = np.zeros((cfx.shape[1], ) * 2, ) if n_orth > 0: assert (n_orth <= cfx.shape[1]) assert (np.allclose(np.eye(n_orth), Sp[:n_orth, :n_orth])) else: n_orth = 0 cf[:n_orth, :n_orth] = np.eye(n_orth) if n_orth < cfx.shape[1]: val, vec = sla.eigh(-Sp[n_orth:, n_orth:]) idx = -val > 1.e-12 U = np.dot(vec[:,idx]*1./(np.sqrt(-val[idx])), \ vec[:,idx].T) cf[n_orth:, n_orth:] = U # define ImpOrbs projection Xp = np.dot(ImpOrbs, ImpOrbs.T) # Si = np.dot(ImpOrbs.T, np.dot(Sp, ImpOrbs)) # Mp = np.dot(ImpOrbs, np.dot(sla.inv(Si), ImpOrbs.T)) Np = np.dot(Sp, Xp) # print np.allclose(Np, np.dot(Np, np.dot(Mp, Np))) _h1 = np.dot(cf.T, np.dot(Hp + jkp - 0.5 * chempot * (Np + Np.T), cf)) _h2 = ao2mo.incore.full(intsp, cf) # prepare BLOCK file, FCIDUMP fcidump.from_integrals('FCIDUMP', _h1, _h2, cfx.shape[1], nel) target = open('dmrg.inp', 'w') output = open('dmrg.out', 'w') target.write('orbitals FCIDUMP\n') target.write('nelec %2d\n' % nel) target.write('spin %2d\n' % 0) target.write('irrep %2d\n' % 1) target.write('\nhf_occ integral\n') target.write('schedule\n') target.write(' %2d %5d %9.1e %9.1e\n' % ( 0, 512, 1e-10, 1e-6, )) target.write(' %2d %5d %9.1e %9.1e\n' % ( 3, 1024, 1e-10, 1e-6, )) target.write(' %2d %5d %9.1e %9.1e\n' % ( 6, 1024, 1e-10, 0.0, )) target.write('end\n') target.write('maxiter %3d\n' % 16) target.write('sweep_tol %9.1e\n' % 1e-8) target.write('onedot\n') target.write('\ntwopdm\n') target.write('outputlevel %2d\n' % 0) target.close() subprocess.call(['mpirun', '-np', '1', block_exe, 'dmrg.inp'], stdout=output) output.close() os.remove('FCIDUMP') os.remove('dmrg.inp') os.remove('dmrg.out') rdm2i = np.loadtxt('node0/spatial_twopdm.0.0.txt', dtype=int, skiprows=1, usecols=( 0, 1, 2, 3, )) rdm2t = np.loadtxt('node0/spatial_twopdm.0.0.txt', dtype=float, skiprows=1, usecols=(4, )) shutil.rmtree('node0') rdm2 = np.zeros((cfx.shape[1], ) * 4) for i in range(rdm2t.shape[0]): rdm2[rdm2i[i, 0], rdm2i[i, 3], rdm2i[i, 1], rdm2i[i, 2]] = 2 * rdm2t[i] rdm1 = np.einsum('ijkk->ij', rdm2) rdm1 /= (nel - 1) del rdm2i, rdm2t # transform rdm's to original basis tei = ao2mo.restore(1, intsp, cfx.shape[1]) rdm1 = np.dot(cf, np.dot(rdm1, cf.T)) rdm2 = np.einsum('ai,ijkl->ajkl', cf, rdm2) rdm2 = np.einsum('bj,ajkl->abkl', cf, rdm2) rdm2 = np.einsum('ck,abkl->abcl', cf, rdm2) rdm2 = np.einsum('dl,abcl->abcd', cf, rdm2) ImpEnergy = +0.25 *np.einsum('ij,jk,ki->', 2*Hp+jkp, rdm1, Xp) \ +0.25 *np.einsum('ij,jk,ki->', 2*Hp+jkp, Xp, rdm1) \ +0.125*np.einsum('ijkl,ijkm,ml->', tei, rdm2, Xp) \ +0.125*np.einsum('ijkl,ijml,mk->', tei, rdm2, Xp) \ +0.125*np.einsum('ijkl,imkl,mj->', tei, rdm2, Xp) \ +0.125*np.einsum('ijkl,mjkl,mi->', tei, rdm2, Xp) Nel = np.trace(np.dot(np.dot(rdm1, Sp), Xp)) return Nel, ImpEnergy
def test_pyscf(U=2, norb=4, periodic=False): nelec = norb n_beta = norb // 2 n_alpha = nelec - n_beta # Define 1D Hubbard hamiltonian h1 = np.zeros((norb, norb)) for i in range(norb - 1): h1[i, i + 1] = h1[i + 1, i] = -1.0 if periodic: h1[norb - 1, 0] = h1[0, norb - 1] = -1.0 # Periodic boundary conditions eri = np.zeros((norb, norb, norb, norb)) for i in range(norb): eri[i, i, i, i] = U from pyscf.tools.fcidump import from_integrals from_integrals('FCIDUMP.PySCF', h1, eri, norb, nelec) # # Generally, direct_spin1.kernel is the FCI object which can handle all generic systems. # e, fcivec = fci.direct_spin1.kernel(h1, eri, norb, nelec, verbose=6) print('FCI Energy is {}'.format(e)) # Alternative options below: # # A better way is to create a FCI (=FCISolver) object because FCI object offers # more options to control the calculation. # cisolver = fci.direct_spin1.FCI() cisolver.max_cycle = 100 cisolver.conv_tol = 1e-8 e, fcivec = cisolver.kernel( h1, eri, norb, (n_alpha, n_beta), verbose=5) # n_alpha alpha, n_beta beta electrons print('FCI Energy is {}'.format(e)) # # If you are sure the system ground state is singlet, you can use spin0 solver. # Spin symmetry is considered in spin0 solver to reduce cimputation cost. # cisolver = fci.direct_spin0.FCI() cisolver.verbose = 5 e, fcivec = cisolver.kernel(h1, eri, norb, nelec) print('FCI Energy is {}'.format(e)) # OPTIONAL: Perform a mean-field hartree-fock calculation, by overwriting some internal objects mol = gto.M(verbose=3) mol.nelectron = nelec # Setting incore_anyway=True to ensure the customized Hamiltonian (the _eri # attribute) to be used in the post-HF calculations. Without this parameter, # some post-HF method (particularly in the MO integral transformation) may # ignore the customized Hamiltonian if memory is not enough. mol.incore_anyway = True mf = scf.RHF(mol) mf.get_hcore = lambda *args: h1 mf.get_ovlp = lambda *args: np.eye(norb) mf._eri = ao2mo.restore(8, eri, norb) e = mf.kernel() print('FCI Energy is {}'.format(e))