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 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!")
