def test_bs(self): sb = StructureBuilder() atoms, *_ = sb.get_structure("C", "diamond") # print(atoms) base_dir = os.path.join(os.path.dirname(__file__), "../../tmp/C-class/") m_calc = MaterCalc(atoms=atoms, base_dir=base_dir) self.assertTrue(m_calc.relax(fmax=0.002)) # Very tight limit! self.assertTrue(m_calc.ground_state()) # get the PBE BS lattice_type = get_cellinfo(m_calc.atoms.cell).lattice self.assertTrue(lattice_type in special_paths.keys()) kpts_bs = dict(path=special_paths[lattice_type], npoints=120) # HSE06 base generate gs_file = os.path.join(base_dir, "gs.gpw") _calc = GPAW(restart=gs_file) atoms = _calc.atoms.copy() calc = GPAW(**_calc.parameters) calc.set(kpts=dict(gamma=True, density=4)) # low density calculations calc.atoms = atoms del _calc calc.get_potential_energy() calc.write(os.path.join(base_dir, "hse.gpw"), mode="all") calc = GPAW(restart=os.path.join(base_dir, "hse.gpw"), txt=None) ns = calc.get_number_of_spins() nk = len(calc.get_ibz_k_points()) nbands = calc.get_number_of_bands() eigen_pbe = numpy.array([[calc.get_eigenvalues(spin=s, kpt=k) \ for k in range(nk)]\ for s in range(ns)]) parprint("EIGEN_PBE", eigen_pbe.shape) vxc_pbe = vxc(calc, "PBE") parprint("VXC_PBE", vxc_pbe.shape) # world.barrier() # HSE06 now calc_hse = EXX(os.path.join(base_dir, "hse.gpw"), xc="HSE06", bands=[0, nbands]) calc_hse.calculate() vxc_hse = calc_hse.get_eigenvalue_contributions() parprint(vxc_hse.shape) parprint(vxc_hse) eigen_hse = eigen_pbe - vxc_pbe + vxc_hse # HSE bandgap from just kpts bg_hse_min, *_ = bandgap(eigenvalues=eigen_hse, efermi=calc.get_fermi_level(), direct=False) bg_hse_dir, *_ = bandgap(eigenvalues=eigen_hse, efermi=calc.get_fermi_level(), direct=True) parprint("HSE: E_min \t E_dir") parprint("{:.3f}\t{:.3f}".format(bg_hse_min, bg_hse_dir)) """
def calculate_exact_exchange(self): name = self.filename + '.exx.npy' fd = opencew(name) if fd is None: print('Reading EXX contribution from file:', name, file=self.fd) with open(name) as fd: self.exx_sin = np.load(fd) assert self.exx_sin.shape == self.shape, self.exx_sin.shape return print('Calculating EXX contribution', file=self.fd) exx = EXX(self.calc, kpts=self.kpts, bands=self.bands, txt=self.filename + '.exx.txt', timer=self.timer) exx.calculate() self.exx_sin = exx.get_eigenvalue_contributions() / Hartree np.save(fd, self.exx_sin)
def xc(filename, xc, ecut=None): """Calculate non self-consitent energy. filename: str Name of restart-file. xc: str Functional ecut: float Plane-wave cutoff for exact exchange. """ name, ext = filename.rsplit('.', 1) assert ext == 'gpw' if xc in ['EXX', 'PBE0', 'B3LYP']: from gpaw.xc.exx import EXX exx = EXX(filename, xc, ecut=ecut, txt=name + '-exx.txt') exx.calculate() e = exx.get_total_energy() else: from gpaw import GPAW calc = GPAW(filename, txt=None) e = calc.get_potential_energy() + calc.get_xc_difference(xc) print(e, 'eV')
def xc(filename, xc, ecut=None): """Calculate non self-consitent energy. filename: str Name of restart-file. xc: str Functional ecut: float Plane-wave cutoff for exact exchange. """ name, ext = filename.rsplit(".", 1) assert ext == "gpw" if xc in ["EXX", "PBE0", "B3LYP"]: from gpaw.xc.exx import EXX exx = EXX(filename, xc, ecut=ecut, txt=name + "-exx.txt") exx.calculate() e = exx.get_total_energy() else: from gpaw import GPAW calc = GPAW(filename, txt=None) e = calc.get_potential_energy() + calc.get_xc_difference(xc) print(e, "eV")
cell = bulk('C', 'fcc', a=3.553).get_cell() a = Atoms('C2', cell=cell, pbc=True, scaled_positions=((0, 0, 0), (0.25, 0.25, 0.25))) calc = GPAW(mode=PW(600), xc='PBE', occupations=FermiDirac(width=0.01), convergence={'density': 1.e-6}, kpts=kpts, parallel={'domain': 1}, txt='diamond.ralda_01_pbe.txt') a.set_calculator(calc) E_pbe = a.get_potential_energy() exx = EXX(calc, txt='diamond.ralda_01_exx.txt') exx.calculate() E_hf = exx.get_total_energy() E_C = np.loadtxt('CO.ralda.PBE_HF_C.dat') f = paropen('diamond.ralda.PBE_HF_diamond.dat', 'w') print('PBE: ', E_pbe / 2 - E_C[0], file=f) print('HF: ', E_hf / 2 - E_C[1], file=f) f.close() calc.diagonalize_full_hamiltonian() calc.write('diamond.ralda.pbe_wfcs.gpw', mode='all')
position=(cell[0, 0] / 3 + cell[1, 0] / 3, cell[0, 1] / 3 + cell[1, 1] / 3)) #view(slab) calc = GPAW(xc='PBE', eigensolver='cg', mode=PW(600), kpts=kpts, occupations=FermiDirac(width=0.01), mixer=MixerSum(beta=0.1, nmaxold=5, weight=50.0), convergence={'density': 1.e-6}, maxiter=300, parallel={ 'domain': 1, 'band': 1 }, txt='gs_%s.txt' % d) slab.set_calculator(calc) E = slab.get_potential_energy() exx = EXX(calc, txt='exx_%s.txt' % d) exx.calculate() E_hf = exx.get_total_energy() calc.diagonalize_full_hamiltonian() calc.write('gs_%s.gpw' % d, mode='all') f = paropen('hf_acdf.dat', 'a') print(d, E, E_hf, file=f) f.close() del slab[-2:]
(0.0000, 0.0000, -1.1560)]), 'Be2': ('Be2', [(0.0000, 0.0000, 0.0000), (0.0000, 0.0000, 2.460)])} c = ase.db.connect('results.db') for name in ex_atomization.keys() + 'H Li Be B C N O F Cl P'.split(): id = c.reserve(name=name) if id is None: continue if name in extra: a = Atoms(*extra[name]) else: a = molecule(name) if name in bondlengths: a.set_distance(0, 1, bondlengths[name]) a.cell = [11, 12, 13] a.center() a.calc = GPAW(xc='PBE', mode=PW(500), txt=name + '.txt', dtype=complex) a.get_potential_energy() exx = EXX(a.calc) exx.calculate() eexx = exx.get_total_energy() c.write(a, name=name, exx=eexx) del c[id]
'size': (k, k, k), 'gamma': True }, xc='PBE', occupations=FermiDirac(0.01), txt='si.pbe+exx.pbe_output.txt', parallel={'band': 1}) bulk_crystal.set_calculator(bulk_calc) e0_bulk_pbe = bulk_crystal.get_potential_energy() # Write to file bulk_calc.write('bulk.gpw', mode='all') # Now the exact exchange exx_bulk = EXX('bulk.gpw', txt='si.pbe+exx.exx_output.txt') exx_bulk.calculate() e0_bulk_exx = exx_bulk.get_total_energy() s = str(alat) s += ' ' s += str(k) s += ' ' s += str(pwcutoff) s += ' ' s += str(e0_bulk_pbe) s += ' ' s += str(e0_bulk_exx) s += '\n' resultfile.write(s)
# CO CO = Atoms('CO', [(0, 0, 0), (0, 0, 1.1283)]) CO.set_pbc(True) CO.center(vacuum=3.0) calc = GPAW(mode=PW(600, force_complex_dtype=True), parallel={'domain': 1}, xc='PBE', txt='CO.ralda_01_CO_pbe.txt', convergence={'density': 1.e-6}) CO.set_calculator(calc) E0_pbe = CO.get_potential_energy() exx = EXX(calc, txt='CO.ralda_01_CO_exx.txt') exx.calculate() E0_hf = exx.get_total_energy() calc.diagonalize_full_hamiltonian() calc.write('CO.ralda.pbe_wfcs_CO.gpw', mode='all') # C C = Atoms('C') C.set_pbc(True) C.set_cell(CO.cell) C.center() calc = GPAW(mode=PW(600, force_complex_dtype=True), parallel={'domain': 1}, xc='PBE',
pbc=(1, 1, 1)) isolated_calc = GPAW(mode=PW(pwcutoff), dtype=complex, kpts=(1, 1, 1), xc='PBE', txt='si_isolated_pbe.txt', occupations=FermiDirac(0.01, fixmagmom=True), spinpol=True, hund=True, convergence={'density': 1.e-6}, mixer=Mixer(beta=0.05, nmaxold=5, weight=50.0)) isolated_silicon.set_calculator(isolated_calc) e0_isolated_pbe = isolated_silicon.get_potential_energy() isolated_calc.write('si.pbe+exx.isolated.gpw', mode='all') # Now the exact exchange exx = EXX('si.pbe+exx.isolated.gpw', txt='si_isolated_exx.txt') exx.calculate() si_isolated_exx = exx.get_total_energy() s = str(L) s += ' ' s += str(e0_isolated_pbe) s += ' ' s += str(si_isolated_exx) s += '\n' myresults.write(s)
mode = PW(pwcutoff), kpts={'size': (k, k, k), 'gamma': True}, dtype=complex, xc='PBE', txt='si.pbe+exx.pbe_output.txt', parallel={'band':1} ) bulk_crystal.set_calculator(bulk_calc) e0_bulk_pbe = bulk_crystal.get_potential_energy() # Write to file bulk_calc.write('bulk.gpw',mode='all') # Now the exact exchange exx_bulk = EXX('bulk.gpw', txt='si.pbe+exx.exx_output.txt') exx_bulk.calculate() e0_bulk_exx = exx_bulk.get_total_energy() s = str(alat) s += ' ' s += str(k) s += ' ' s += str(pwcutoff) s += ' ' s += str(e0_bulk_pbe) s += ' ' s += str(e0_bulk_exx) s += '\n' resultfile.write(s)
import ase.db from ase.build import bulk import numpy as np from gpaw.xc.exx import EXX from gpaw import GPAW, PW a0 = 5.43 con = ase.db.connect('si.db') for k in range(2, 9): for a in np.linspace(a0 - 0.04, a0 + 0.04, 5): id = con.reserve(a=a, k=k) if id is None: continue si = bulk('Si', 'diamond', a) si.calc = GPAW(kpts=(k, k, k), mode=PW(400), xc='PBE', eigensolver='rmm-diis', txt=None) si.get_potential_energy() name = 'si-{0:.2f}-{1}'.format(a, k) si.calc.write(name + '.gpw', mode='all') pbe0 = EXX(name + '.gpw', 'PBE0', txt=name + '.pbe0.txt') pbe0.calculate() epbe0 = pbe0.get_total_energy() con.write(si, a=a, k=k, epbe0=epbe0) del con[id]
kpt_indices = [] pbeeigs = [] for kpt in [(0, 0, 0), (0.5, 0.5, 0)]: # Find k-point index: i = abs(ibzkpts - kpt).sum(1).argmin() kpt_indices.append(i) pbeeigs.append(si.calc.get_eigenvalues(i)[n1:n2]) # DFT eigenvalues: pbeeigs = np.array(pbeeigs) # PBE contribution: dpbeeigs = vxc(si.calc, 'PBE')[0, kpt_indices, n1:n2] # Do PBE0 calculation: pbe0 = EXX(name + '.gpw', 'PBE0', kpts=kpt_indices, bands=[n1, n2], txt=name + '.pbe0.txt') pbe0.calculate() dpbe0eigs = pbe0.get_eigenvalue_contributions()[0] pbe0eigs = pbeeigs - dpbeeigs + dpbe0eigs print('{0}, {1:.3f}, {2:.3f}, {3:.3f}, {4:.3f}'.format( k, pbeeigs[0, 1] - pbeeigs[0, 0], pbeeigs[1, 1] - pbeeigs[0, 0], pbe0eigs[0, 1] - pbe0eigs[0, 0], pbe0eigs[1, 1] - pbe0eigs[0, 0]), file=fd) fd.flush()
def XC(kernel, parameters=None, atoms=None, collinear=True): """Create XCFunctional object. kernel: XCKernel object, dict or str Kernel object or name of functional. parameters: ndarray Parameters for BEE functional. Recognized names are: LDA, PW91, PBE, revPBE, RPBE, BLYP, HCTH407, TPSS, M06-L, revTPSS, vdW-DF, vdW-DF2, EXX, PBE0, B3LYP, BEE, GLLBSC. One can also use equivalent libxc names, for example GGA_X_PBE+GGA_C_PBE is equivalent to PBE, and LDA_X to the LDA exchange. In this way one has access to all the functionals defined in libxc. See xc_funcs.h for the complete list. """ if isinstance(kernel, basestring): kernel = xc_string_to_dict(kernel) kwargs = {} if isinstance(kernel, dict): kwargs = kernel.copy() name = kwargs.pop('name') backend = kwargs.pop('backend', None) if backend == 'libvdwxc' or name == 'vdW-DF-cx': # Must handle libvdwxc before old vdw implementation to override # behaviour for 'name'. Also, cx is not implemented by the old # vdW module, so that always refers to libvdwxc. from gpaw.xc.libvdwxc import get_libvdwxc_functional return get_libvdwxc_functional(name=name, **kwargs) elif backend: error_msg = "A special backend for the XC functional was given, "\ "but not understood. Please check if there's a typo." raise ValueError(error_msg) if name in ['vdW-DF', 'vdW-DF2', 'optPBE-vdW', 'optB88-vdW', 'C09-vdW', 'mBEEF-vdW', 'BEEF-vdW']: from gpaw.xc.vdw import VDWFunctional return VDWFunctional(name, **kwargs) elif name in ['EXX', 'PBE0', 'B3LYP', 'CAMY-BLYP', 'CAMY-B3LYP', 'LCY-BLYP', 'LCY-PBE']: from gpaw.xc.hybrid import HybridXC return HybridXC(name, **kwargs) elif name.startswith('LCY-') or name.startswith('CAMY-'): parts = name.split('(') from gpaw.xc.hybrid import HybridXC return HybridXC(parts[0], omega=float(parts[1][:-1])) elif name in ['HSE03', 'HSE06']: from gpaw.xc.exx import EXX return EXX(name, **kwargs) elif name == 'BEE1': from gpaw.xc.bee import BEE1 kernel = BEE1(parameters) elif name == 'BEE2': from gpaw.xc.bee import BEE2 kernel = BEE2(parameters) elif name.startswith('GLLB'): from gpaw.xc.gllb.nonlocalfunctionalfactory import \ NonLocalFunctionalFactory # Pass kwargs somewhere? xc = NonLocalFunctionalFactory().get_functional_by_name(name) xc.print_functional() return xc elif name == 'LB94': from gpaw.xc.lb94 import LB94 kernel = LB94() elif name == 'TB09': from gpaw.xc.tb09 import TB09 return TB09(**kwargs) elif name.endswith('PZ-SIC'): from gpaw.xc.sic import SIC return SIC(xc=name[:-7], **kwargs) elif name in ['TPSS', 'M06-L', 'M06L', 'revTPSS']: if name == 'M06L': name = 'M06-L' warnings.warn('Please use M06-L instead of M06L') from gpaw.xc.kernel import XCKernel kernel = XCKernel(name) elif name.startswith('old'): from gpaw.xc.kernel import XCKernel kernel = XCKernel(name[3:]) elif name == 'PPLDA': from gpaw.xc.lda import PurePythonLDAKernel kernel = PurePythonLDAKernel() elif name in ['pyPBE', 'pyPBEsol', 'pyRPBE', 'pyzvPBEsol']: from gpaw.xc.gga import PurePythonGGAKernel kernel = PurePythonGGAKernel(name) elif name == '2D-MGGA': from gpaw.xc.mgga import PurePython2DMGGAKernel kernel = PurePython2DMGGAKernel(name, parameters) elif name[0].isdigit(): from gpaw.xc.parametrizedxc import ParametrizedKernel kernel = ParametrizedKernel(name) elif name == 'null': from gpaw.xc.kernel import XCNull kernel = XCNull() elif name == 'QNA': from gpaw.xc.qna import QNA return QNA(atoms, kernel['parameters'], kernel['setup_name'], alpha=kernel['alpha'], stencil=kwargs.get('stencil', 2)) else: kernel = LibXC(name) if kernel.type == 'LDA': if not collinear: kernel = NonCollinearLDAKernel(kernel) xc = LDA(kernel, **kwargs) return xc elif kernel.type == 'GGA': return GGA(kernel, **kwargs) else: return MGGA(kernel, **kwargs)
pos = slab.get_positions() add_adsorbate(slab, 'C', d, position=(pos[3,0], pos[3,1])) add_adsorbate(slab, 'C', d, position=(cell[0,0]/3 + cell[1,0]/3, cell[0,1]/3 + cell[1,1]/3)) #view(slab) calc = GPAW(xc='PBE', eigensolver='cg', mode=PW(600), kpts=kpts, occupations=FermiDirac(width=0.01), mixer=MixerSum(beta=0.1, nmaxold=5, weight=50.0), convergence={'density': 1.e-6}, maxiter=300, parallel={'domain': 1, 'band': 1}, txt='gs_%s.txt' % d) slab.set_calculator(calc) E = slab.get_potential_energy() exx = EXX(calc, txt='exx_%s.txt' % d) exx.calculate() E_hf = exx.get_total_energy() calc.diagonalize_full_hamiltonian() calc.write('gs_%s.gpw' % d, mode='all') f = paropen('hf_acdf.dat', 'a') print(d, E, E_hf, file=f) f.close() del slab[-2:]
N.cell = (6, 6, 7) N.center() calc = GPAW(mode=PW(600, force_complex_dtype=True), nbands=8, maxiter=300, xc='PBE', hund=True, txt='N_pbe.txt', convergence={'density': 1.e-6}) N.calc = calc E1_pbe = N.get_potential_energy() calc.write('N.gpw', mode='all') exx = EXX('N.gpw', txt='N_exx.txt') exx.calculate() E1_hf = exx.get_total_energy() calc.diagonalize_full_hamiltonian(nbands=4800) calc.write('N.gpw', mode='all') # N2 N2 = molecule('N2') N2.cell = (6, 6, 7) N2.center() calc = GPAW(mode=PW(600, force_complex_dtype=True), maxiter=300, xc='PBE', txt='N2_pbe.txt', convergence={'density': 1.e-6})
def XC(kernel, parameters=None): """Create XCFunctional object. kernel: XCKernel object or str Kernel object or name of functional. parameters: ndarray Parameters for BEE functional. Recognized names are: LDA, PW91, PBE, revPBE, RPBE, BLYP, HCTH407, TPSS, M06-L, revTPSS, vdW-DF, vdW-DF2, EXX, PBE0, B3LYP, BEE, GLLBSC. One can also use equivalent libxc names, for example GGA_X_PBE+GGA_C_PBE is equivalent to PBE, and LDA_X to the LDA exchange. In this way one has access to all the functionals defined in libxc. See xc_funcs.h for the complete list. """ if isinstance(kernel, basestring): name = kernel if name in [ 'vdW-DF', 'vdW-DF2', 'optPBE-vdW', 'optB88-vdW', 'C09-vdW', 'mBEEF-vdW', 'BEEF-vdW' ]: from gpaw.xc.vdw import VDWFunctional return VDWFunctional(name) elif name in ['EXX', 'PBE0', 'B3LYP']: from gpaw.xc.hybrid import HybridXC return HybridXC(name) elif name in ['HSE03', 'HSE06']: from gpaw.xc.exx import EXX return EXX(name) elif name == 'BEE1': from gpaw.xc.bee import BEE1 kernel = BEE1(parameters) elif name == 'BEE2': from gpaw.xc.bee import BEE2 kernel = BEE2(parameters) elif name.startswith('GLLB'): from gpaw.xc.gllb.nonlocalfunctionalfactory import \ NonLocalFunctionalFactory xc = NonLocalFunctionalFactory().get_functional_by_name(name) xc.print_functional() return xc elif name == 'LB94': from gpaw.xc.lb94 import LB94 kernel = LB94() elif name == 'TB09': from gpaw.xc.tb09 import TB09 return TB09() elif name.startswith('ODD_'): from ODD import ODDFunctional return ODDFunctional(name[4:]) elif name.endswith('PZ-SIC'): try: from ODD import PerdewZungerSIC as SIC return SIC(xc=name[:-7]) except: from gpaw.xc.sic import SIC return SIC(xc=name[:-7]) elif name in ['TPSS', 'M06-L', 'M06L', 'revTPSS']: if name == 'M06L': name = 'M06-L' warnings.warn('Please use M06-L instead of M06L') from gpaw.xc.kernel import XCKernel kernel = XCKernel(name) elif name.startswith('old'): from gpaw.xc.kernel import XCKernel kernel = XCKernel(name[3:]) elif name == 'PPLDA': from gpaw.xc.lda import PurePythonLDAKernel kernel = PurePythonLDAKernel() elif name in ['pyPBE', 'pyPBEsol', 'pyRPBE', 'pyzvPBEsol']: from gpaw.xc.gga import PurePythonGGAKernel kernel = PurePythonGGAKernel(name) elif name == '2D-MGGA': from gpaw.xc.mgga import PurePython2DMGGAKernel kernel = PurePython2DMGGAKernel(name, parameters) elif name[0].isdigit(): from gpaw.xc.parametrizedxc import ParametrizedKernel kernel = ParametrizedKernel(name) else: kernel = LibXC(kernel) if kernel.type == 'LDA': return LDA(kernel) elif kernel.type == 'GGA': return GGA(kernel) else: return MGGA(kernel)
# CO ------------------------------------------ CO = Atoms('CO', [(0, 0, 0), (0, 0, 1.1283)]) CO.set_pbc(True) CO.center(vacuum=3.0) calc = GPAW(mode=PW(600), dtype=complex, xc='PBE', txt='CO_pbe.txt', convergence={'density': 1.e-6}) CO.set_calculator(calc) E0_pbe= CO.get_potential_energy() exx = EXX(calc, txt='CO_exx.txt') exx.calculate() E0_hf = exx.get_total_energy() calc.diagonalize_full_hamiltonian() calc.write('CO.gpw', mode='all') # C ------------------------------------------- C = Atoms('C') C.set_pbc(True) C.set_cell(CO.cell) C.center() calc = GPAW(mode=PW(600), dtype=complex, xc='PBE',
ibzk_kc = atoms.calc.get_ibz_k_points() n = int(atoms.calc.get_number_of_electrons()) // 2 ibzk = [] eps_kn = [] for k_c in [(0, 0, 0), (0.5, 0.5, 0), (0.5, 0.5, 0.5)]: k = abs(ibzk_kc - k_c).max(1).argmin() ibzk.append(k) eps_kn.append(atoms.calc.get_eigenvalues(k)[n - 1:n + 1]) if name == 'Ar': break deps_kn = vxc(atoms.calc, 'PBE')[0, ibzk, n - 1:n + 1] pbe0 = EXX(name, 'PBE0', ibzk, (n - 1, n + 1), txt=name + '.exx') pbe0.calculate() deps0_kn = pbe0.get_eigenvalue_contributions()[0] eps0_kn = eps_kn - deps_kn + deps0_kn data = {} for k, point in enumerate('GXL'): data[point] = [eps_kn[k][1] - eps_kn[0][0], eps0_kn[k, 1] - eps0_kn[0, 0]] data[point] += bfb[name][2 + k * 4:6 + k * 4] if name == 'Ar': break c.write(atoms, name=name, data=data) del c[id]
ecut = 25 N2 = molecule('N2') N2.center(vacuum=2.0) calc = GPAW(mode=PW(force_complex_dtype=True), xc='PBE', parallel={'domain': 1}, eigensolver='rmm-diis') N2.set_calculator(calc) E_n2_pbe = N2.get_potential_energy() calc.diagonalize_full_hamiltonian(nbands=104, scalapack=True) calc.write('N2.gpw', mode='all') exx = EXX('N2.gpw') exx.calculate() E_n2_hf = exx.get_total_energy() rpa = RPACorrelation('N2.gpw', nfrequencies=8) E_n2_rpa = rpa.calculate(ecut=[ecut]) N = molecule('N') N.set_cell(N2.cell) calc = GPAW(mode=PW(force_complex_dtype=True), xc='PBE', parallel={'domain': 1}, eigensolver='rmm-diis') N.set_calculator(calc) E_n_pbe = N.get_potential_energy()
ibzk_kc = atoms.calc.get_ibz_k_points() n = int(atoms.calc.get_number_of_electrons()) // 2 ibzk = [] eps_kn = [] for k_c in [(0, 0, 0), (0.5, 0.5, 0), (0.5, 0.5, 0.5)]: k = abs(ibzk_kc - k_c).max(1).argmin() ibzk.append(k) eps_kn.append(atoms.calc.get_eigenvalues(k)[n - 1:n + 1]) if name == 'Ar': break deps_kn = vxc(atoms.calc, 'PBE')[0, ibzk, n - 1:n + 1] pbe0 = EXX(name + '.gpw', 'PBE0', ibzk, (n - 1, n + 1), txt=name + '.exx') pbe0.calculate() deps0_kn = pbe0.get_eigenvalue_contributions()[0] eps0_kn = eps_kn - deps_kn + deps0_kn data = {} for k, point in enumerate('GXL'): data[point] = [eps_kn[k][1] - eps_kn[0][0], eps0_kn[k, 1] - eps0_kn[0, 0]] data[point] += bfb[name][2 + k * 4:6 + k * 4] if name == 'Ar': break c.write(atoms, name=name, data=data) del c[id]
isolated_calc = GPAW( mode=PW(pwcutoff), dtype=complex, kpts=(1, 1, 1), xc="PBE", txt="si_isolated_pbe.txt", occupations=FermiDirac(0.01, fixmagmom=True), spinpol=True, hund=True, convergence={"density": 1.0e-6}, mixer=Mixer(beta=0.05, nmaxold=5, weight=50.0), ) isolated_silicon.set_calculator(isolated_calc) e0_isolated_pbe = isolated_silicon.get_potential_energy() isolated_calc.write("si.pbe+exx.isolated.gpw", mode="all") # Now the exact exchange exx = EXX("si.pbe+exx.isolated.gpw", txt="si_isolated_exx.txt") exx.calculate() si_isolated_exx = exx.get_total_energy() s = str(L) s += " " s += str(e0_isolated_pbe) s += " " s += str(si_isolated_exx) s += "\n" myresults.write(s)
def hse(base_dir="./", kdens=6.0): emptybands = 20 convbands = 10 # If pbc in z direction, use vdW for relaxation as default! # if atoms.pbc[-1]: # Do not compare with np.bool_ ! # use_vdW = True # else: # use_vdW = False curr_dir = os.path.dirname(os.path.abspath(__file__)) param_file = os.path.join(curr_dir, "../parameters.json") gpw_file = os.path.join(base_dir, "gs.gpw") hse_file = os.path.join(base_dir, "hse.gpw") hse_nowfs_file = os.path.join(base_dir, "hse_nowfs.gpw") hse_eigen_file = os.path.join(base_dir, "hse_eigenvalues.npz") if not os.path.exists(gpw_file): parprint("No ground state calculation? Exit...") return 0 if os.path.exists(param_file): params = json.load(open(param_file, "r")) else: raise FileNotFoundError("no parameter file!") if not os.path.exists(hse_file): calc = GPAW(gpw_file) # reload the calculation atoms = calc.get_atoms() kpts = get_kpts_size(atoms, kdens) calc.set(nbands=-emptybands, fixdensity=True, kpts=kpts, convergence={'bands': -convbands}) calc.get_potential_energy() calc.write(hse_file, 'all') calc.write(hse_nowfs_file) # no wavefunction mpi.world.barrier() time.sleep(10) # is this needed? calc = GPAW(hse_file, txt=None) ns = calc.get_number_of_spins() nk = len(calc.get_ibz_k_points()) nb = calc.get_number_of_bands() vxc_pbe_skn = vxc(calc, 'PBE') vxc_pbe_nsk = numpy.ascontiguousarray(vxc_pbe_skn.transpose(2, 0, 1)) vxc_pbe_nsk = calc.wfs.bd.collect(vxc_pbe_nsk, broadcast=True) vxc_pbe_skn = vxc_pbe_nsk.transpose(1, 2, 0)[:, :, :-convbands] e_pbe_skn = np.zeros((ns, nk, nb)) for s in range(ns): for k in range(nk): e_pbe_skn[s, k, :] = calc.get_eigenvalues(spin=s, kpt=k) e_pbe_skn = e_pbe_skn[:, :, :-convbands] hse_calc = EXX(hse_file, xc='HSE06', bands=[0, nb - convbands]) hse_calc.calculate() vxc_hse_skn = hse_calc.get_eigenvalue_contributions() e_hse_skn = e_pbe_skn - vxc_pbe_skn + vxc_hse_skn ranks = [0] if mpi.world.rank in ranks: dct = dict(vxc_hse_skn=vxc_hse_skn, e_pbe_skn=e_pbe_skn, vxc_pbe_skn=vxc_pbe_skn, e_hse_skn=e_hse_skn) with open(hse_eigen_file, 'wb') as f: numpy.savez(f, **dct) parprint("Single HSE06 finished!")