def check_df(name, ref_energy, ref_loss, ref_energy_lfe, ref_loss_lfe,
**kwargs_override):
kwargs = dict(calc=calc, frequencies=w.copy(), eta=0.5, ecut=30,
txt='df.%s.txt' % name)
kwargs.update(kwargs_override)
df = DielectricFunction(**kwargs)
fname = 'dfdump.%s.dat' % name
df.get_eels_spectrum('RPA',q_c=q,filename=fname)
world.barrier()
d = np.loadtxt(fname,delimiter=',')
loss = d[:, 1]
loss_lfe = d[:, 2]
energies = d[:, 0]
#import pylab as pl
#fig = pl.figure()
#ax1 = fig.add_subplot(111)
#ax1.plot(d[:, 0], d[:, 1]/np.max(d[:, 1]))
#ax1.plot(d[:, 0], d[:, 2]/np.max(d[:, 2]))
#ax1.axis(ymin=0, ymax=1)
#fig.savefig('fig.%s.pdf' % name)
energy, peakloss = getpeak(energies, loss)
energy_lfe , peakloss_lfe = getpeak(energies, loss_lfe)
check(name, energy, peakloss, ref_energy, ref_loss)
check('%s-lfe' % name, energy_lfe, peakloss_lfe, ref_energy_lfe,
ref_loss_lfe)
line = template % (name, energy, peakloss, energy_lfe, peakloss_lfe,
repr(kwargs_override))
scriptlines.append(line)
def polarizability(base_dir="./", mode="df", fermi_shift=None):
curr_dir = os.path.dirname(os.path.abspath(__file__))
es_gpw = os.path.join(base_dir, "es.gpw")
param_file = os.path.join(curr_dir, "../parameters.json")
if os.path.exists(param_file):
params = json.load(open(param_file, "r"))
else:
raise FileNotFoundError("no parameter file!")
if not os.path.exists(es_gpw):
raise FileNotFoundError("Excited state not calculated!")
if mode not in ("df", "tetra"):
raise ValueError("Mode should be df or tetra")
if fermi_shift is None:
data_file = os.path.join(base_dir,
"polarizability_{}.npz".format(mode))
else:
data_file = os.path.join(base_dir,
"polarizability_{}_{:.2f}.npz".format(mode, fermi_shift))
params[mode]["intraband"] = True
if os.path.exists(data_file):
parprint("Polarizability file exists!")
return 0
df = DielectricFunction(calc=es_gpw,
**params[mode],
gate_voltage=fermi_shift) # add energy shift
alpha0x, alphax = df.get_polarizability(q_c=[0, 0, 0],
direction="x",
pbc=[True, True, False],
filename=None)
alpha0y, alphay = df.get_polarizability(q_c=[0, 0, 0],
direction="y",
pbc=[True, True, False],
filename=None)
alpha0z, alphaz = df.get_polarizability(q_c=[0, 0, 0],
direction="z",
pbc=[True, True, False],
filename=None)
freq = df.get_frequencies()
data = dict(frequencies=freq,
alpha_x=alphax,
alpha_y=alphay,
alpha_z=alphaz,
alpha_x0=alpha0x,
alpha_y0=alpha0y,
alpha_z0=alpha0z,)
from ase.parallel import world
import numpy
if world.rank == 0:
numpy.savez_compressed(data_file, **data)
def permittivity(base_dir="./", mode="df"):
curr_dir = os.path.dirname(os.path.abspath(__file__))
es_gpw = os.path.join(base_dir, "es.gpw")
param_file = os.path.join(curr_dir, "../parameters.json")
if os.path.exists(param_file):
params = json.load(open(param_file, "r"))
else:
raise FileNotFoundError("no parameter file!")
if not os.path.exists(es_gpw):
raise FileNotFoundError("Excited state not calculated!")
if mode not in ("df", "tetra"):
raise ValueError("Mode should be df or tetra")
data_file = os.path.join(base_dir, "polarizability_{}.npz".format(mode))
if os.path.exists(data_file):
parprint("Polarizability file exists!")
return 0
df = DielectricFunction(calc=es_gpw, **params[mode])
eps0x, epsx = df.get_dielectric_function(
q_c=[0, 0, 0],
direction="x",
#pbc=[True, True, False],
filename=None)
eps0y, epsy = df.get_dielectric_function(
q_c=[0, 0, 0],
direction="y",
#pbc=[True, True, False],
filename=None)
eps0z, epsz = df.get_dielectric_function(
q_c=[0, 0, 0],
direction="z",
#pbc=[True, True, False],
filename=None)
freq = df.get_frequencies()
data = dict(
frequencies=freq,
eps_x=epsx,
eps_y=epsy,
eps_z=epsz,
eps_x0=eps0x,
eps_y0=eps0y,
eps_z0=eps0z,
)
from ase.parallel import world
import numpy
if world.rank == 0:
numpy.savez_compressed(data_file, **data)
def bb_file(mater):
f_name = os.path.join(os.path.curdir, "{}-chi.npz".format(mater))
if os.path.exists(f_name):
return f_name
else: # Calculate the BB
parprint("Chi matrix not calculated, build for now!")
df = DielectricFunction(calc=es_wfs(mater),
eta=0.1,
intraband=False,
truncation="2D")
bb = BuildingBlock(mater, df, qmax=3)
bb.calculate_building_block()
return f_name
def get_hydrogen_chain_dielectric_function(NH, NK):
a = Atoms('H', cell=[1, 1, 1], pbc=True)
a.center()
a = a.repeat((1, 1, NH))
a.calc = GPAW(mode=PW(200, force_complex_dtype=True),
kpts={'size': (1, 1, NK), 'gamma': True},
parallel={'band': 1},
gpts=(10, 10, 10 * NH))
a.get_potential_energy()
a.calc.diagonalize_full_hamiltonian(nbands=2 * NH)
a.calc.write('H_chain.gpw', 'all')
DF = DielectricFunction('H_chain.gpw', ecut=1e-3, hilbert=False,
omega2=np.inf, intraband=False)
eps_NLF, eps_LF = DF.get_dielectric_function(direction='z')
omega_w = DF.get_frequencies()
return omega_w, eps_LF
def dielectric(self, method="rpa"):
method = method.lower()
if method not in ("rpa", "gw"):
raise ValueError("Dielectric Method not known!")
if not os.path.exists(self.__es_file):
raise FileNotFoundError("Ground state not calculated!")
self.__eps_file = self.__eps_file_template.format(method)
if os.path.exists(self.__eps_file):
parprint(("Dielectricfunction using"
" method {} already calculated!").format(method))
return True
if os.path.exists(self.__es_file):
parprint("Excited state done, will use directly!")
if method == "rpa":
df = DielectricFunction(calc=self.__es_file, **self.params[method])
epsx0, epsx = df.get_dielectric_function(direction="x",
filename=None)
epsy0, epsy = df.get_dielectric_function(direction="y",
filename=None)
epsz0, epsz = df.get_dielectric_function(direction="z",
filename=None)
freq = df.get_frequencies()
data = dict(frequencies=freq,
eps_x=epsx,
eps_x0=epsx0,
eps_y=epsy,
eps_y0=epsy0,
eps_z=epsz,
eps_z0=epsz)
# write result
if rank == 0:
numpy.savez(self.__eps_file, **data)
parprint("Dielectric function using {} calculated!".format(method))
return True
else:
raise NotImplementedError("{} not implemented".format(method))
import numpy as np
from gpaw.response.bse import BSE
from gpaw.response.df import DielectricFunction
ecut = 50
eshift = 0.8
eta = 0.2
df = DielectricFunction('gs_Si.gpw',
ecut=ecut,
frequencies=np.linspace(0., 10., 1001),
nbands=8,
intraband=False,
hilbert=False,
eta=eta,
eshift=eshift,
txt='rpa_Si.txt')
df.get_dielectric_function(filename='eps_rpa_Si.csv')
bse = BSE('gs_Si.gpw',
ecut=ecut,
valence_bands=range(0, 4),
conduction_bands=range(4, 8),
nbands=50,
eshift=eshift,
mode='BSE',
integrate_gamma=0,
txt='bse_Si.txt')
bse.get_dielectric_function(filename='eps_bse_Si.csv',
gamma=True),
occupations=FermiDirac(0.001),
xc="PBE",
basis="dzp",
poissonsolver=dict(dipolelayer="xy"))
mol.set_calculator(calc)
# Get ground state
mol.get_potential_energy()
calc.diagonalize_full_hamiltonian(nbands=30) # Full diagonalization
calc.write("MoS2_gs.gpw", mode="all")
# Dielectric Response
df = DielectricFunction(calc="MoS2_gs.gpw",
eta=0.05,
domega0=0.02,
truncation="2D", # truncation
ecut=50)
alpha0x, alphax = df.get_polarizability(q_c=[0, 0, 0],
direction='x',
pbc=[True, True, False],
filename="MoS2_alpha_x.csv")
alpha0z, alphaz = df.get_polarizability(q_c=[0, 0, 0],
direction='z',
pbc=[True, True, False],
filename="MoS2_alpha_z.csv")
from gpaw import GPAW
from gpaw.response.df import DielectricFunction
calc = GPAW('Ag_GLLBSC.gpw')
calc.diagonalize_full_hamiltonian(nbands=30)
calc.write('Ag_GLLBSC_full.gpw', 'all')
# Set up dielectric function:
df = DielectricFunction(calc='Ag_GLLBSC_full.gpw', # Ground state input
domega0=0.05) # energy grid spacing at omega=0
# Momentum transfer, must be the difference between two kpoints!
q_c = [1.0 / 10, 0, 0]
df.get_eels_spectrum(q_c=q_c) # a file called 'eels.csv' is generated
# Plot spectrum
import numpy as np
import matplotlib.pyplot as plt
data = np.loadtxt('eels.csv', delimiter=',')
omega = data[:, 0]
eels = data[:, 2]
plt.plot(omega, eels)
plt.xlabel('Energy (eV)')
plt.ylabel('Loss spectrum')
plt.xlim(0, 20)
plt.show()
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('C.gpw', 'all')
eM1_ = 9.727
eM2_ = 9.548
w0_ = 10.7782
I0_ = 5.5472
w_ = 10.7532
I_ = 6.0686
# Macroscopic dielectric constant calculation
df = DielectricFunction('C.gpw',
frequencies=(0., ),
eta=0.001,
ecut=50,
hilbert=False)
eM1, eM2 = df.get_macroscopic_dielectric_constant()
equal(eM1, eM1_, 0.01)
equal(eM2, eM2_, 0.01)
# Absorption spectrum calculation RPA
df = DielectricFunction('C.gpw',
eta=0.25,
ecut=50,
frequencies=np.linspace(0, 24., 241),
hilbert=False)
a0, a = df.get_dielectric_function(filename=None)
df.check_sum_rule(a.imag)
calc = GPAW(mode=PW(ecut=400),
nbands=8,
xc='PBE',
kpts={
'size': [nk, nk, 1],
'gamma': True
},
experimental={'kpt_refine': kpt_refine},
occupations=FermiDirac(0.026))
system.set_calculator(calc)
system.get_potential_energy()
calc.write('graphene.gpw', 'all')
pbc = system.pbc
df = DielectricFunction('graphene.gpw', eta=25e-3, domega0=0.01)
alpha0x_w, alphax_w = df.get_polarizability(q_c=[1 / (nk * nkrefine), 0, 0])
omega_w = df.get_frequencies()
analyticalalpha_w = 1j / (8 * omega_w[1:] / Hartree)
# Just some hardcoded test for alpha at omega=0
equal(alphax_w[0].real,
6.705,
tolerance=0.02,
msg='Polarizability at omega=0 is wrong')
if 0:
from matplotlib import pyplot as plt
plt.plot(omega_w, alphax_w.real, label='GPAW real part')
plt.plot(omega_w, alphax_w.imag, '--', label='GPAW imag part')
plt.plot(omega_w[1:],
from __future__ import print_function
from gpaw.response.df import DielectricFunction
df = DielectricFunction('gs_MoS2.gpw',
ecut=100,
frequencies=(0., ),
nbands=50,
intraband=False,
hilbert=False,
eta=0.1)
alpha = df.get_polarizability(pbc=[True, True, False],
filename=None)[1][0].real
print('alpha = ', alpha, 'AA')
atoms.set_calculator(calc)
atoms.get_potential_energy() # Get ground state density
# Restart Calculation with fixed density and dense kpoint sampling
calc.set(
kpts={
'density': 15.0,
'gamma': False
}, # Dense kpoint sampling
fixdensity=True)
atoms.get_potential_energy()
calc.diagonalize_full_hamiltonian(nbands=70) # Diagonalize Hamiltonian
calc.write('si_large.gpw', 'all') # Write wavefunctions
# Getting absorption spectrum
df = DielectricFunction(calc='si_large.gpw', eta=0.05, domega0=0.02, ecut=150)
df.get_dielectric_function(filename='si_abs.csv')
# Getting macroscopic constant
df = DielectricFunction(
calc='si_large.gpw',
frequencies=[0.0],
hilbert=False,
eta=0.0001,
ecut=150,
)
epsNLF, epsLF = df.get_macroscopic_dielectric_constant()
# Make table
epsrefNLF = 14.08 # From [1] in top
for GSkwargs in GSsettings:
calc = GPAW(h=0.18,
mode=PW(600),
occupations=FermiDirac(0.2),
**GSkwargs)
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('gr.gpw', 'all')
dfs = []
for kwargs in DFsettings:
DF = DielectricFunction(calc='gr.gpw',
domega0=0.2,
eta=0.2,
ecut=40.0,
**kwargs)
df1, df2 = DF.get_dielectric_function()
if world.rank == 0:
dfs.append(df1)
# Check the calculated dielectric functions against
# each other.
while len(dfs):
df = dfs.pop()
for DFkwargs, df2 in zip(DFsettings[-len(dfs):], dfs):
try:
assert np.allclose(df, df2)
print('Ground state settings:', GSkwargs)
print('DFkwargs1:', DFsettings[-len(dfs) - 1])
calc.set(kpts=(20, 20, 7), fixdensity=True)
# atoms.get_potential_energy()
# The result should also be converged with respect to bands:
calc.diagonalize_full_hamiltonian(nbands=60)
calc.write('caf2.gpw', 'all')
# Part 2: Spectra calculations
f = paropen(output_folder + '/caf2_q_list', 'w') # write q
for i in range(1, 6): # loop over different q
df = DielectricFunction(
calc='caf2.gpw',
domega0=0.01,
eta=0.2, # Broadening parameter.
ecut=100,
# write different output for different q:
txt='%s/out_df_%d.txt' % (output_folder, i))
q_c = [i / 20.0, 0.0, 0.0] # Gamma - M excitation
df.get_eels_spectrum(q_c=q_c,
filename='%s/caf2_EELS_%d' % (output_folder, i))
# Calculate cartesian momentum vector:
cell_cv = atoms.get_cell()
bcell_cv = 2 * np.pi * np.linalg.inv(cell_cv).T
q_v = np.dot(q_c, bcell_cv)
print(sqrt(np.inner(q_v, q_v)), file=f)
from ase.build import bulk
from gpaw import GPAW
from gpaw.response.df import DielectricFunction
# Part 1: Ground state calculation
atoms = bulk('Al', 'fcc', a=4.043) # generate fcc crystal structure
# GPAW calculator initialization:
k = 13
calc = GPAW(mode='pw', kpts=(k, k, k))
atoms.set_calculator(calc)
atoms.get_potential_energy() # ground state calculation is performed
calc.write('Al.gpw', 'all') # use 'all' option to write wavefunctions
# Part 2: Spectrum calculation
df = DielectricFunction(calc='Al.gpw') # ground state gpw file as input
# Momentum transfer, must be the difference between two kpoints:
q_c = [1.0 / k, 0, 0]
df.get_eels_spectrum(q_c=q_c) # by default, an 'eels.csv' file is generated
a1.calc = GPAW(gpts=(10, 10, 10),
mode=PW(300),
kpts={
'size': (30, 30, 30),
'gamma': True
},
parallel={'band': 1},
txt='small.txt')
a1.get_potential_energy()
a1.calc.diagonalize_full_hamiltonian(nbands=20)
a1.calc.write('gs_Na.gpw', 'all')
# Calculate the dielectric functions
df1 = DielectricFunction('gs_Na.gpw', nblocks=1, ecut=400, txt='1block.txt')
df1NLFCx, df1LFCx = df1.get_dielectric_function(direction='x')
df1NLFCy, df1LFCy = df1.get_dielectric_function(direction='y')
df1NLFCz, df1LFCz = df1.get_dielectric_function(direction='z')
df2 = DielectricFunction('gs_Na.gpw', nblocks=4, ecut=400, txt='4block.txt')
df2NLFCx, df2LFCx = df2.get_dielectric_function(direction='x')
df2NLFCy, df2LFCy = df2.get_dielectric_function(direction='y')
df2NLFCz, df2LFCz = df2.get_dielectric_function(direction='z')
# Compare plasmon frequencies and intensities
w_w = df1.chi0.omega_w
w1, I1 = findpeak(w_w, -(1. / df1LFCx).imag)
w2, I2 = findpeak(w_w, -(1. / df2LFCx).imag)
mode=PW(300),
kpts={
'size': (30, 30, 30),
'gamma': True
},
parallel={'band': 1},
txt='small.txt')
a1.get_potential_energy()
a1.calc.diagonalize_full_hamiltonian(nbands=20)
a1.calc.write('gs_Na.gpw', 'all')
kwargs = {'integrationmode': 'tetrahedron integration', 'ecut': 400}
# Calculate the dielectric functions
df1 = DielectricFunction('gs_Na.gpw', nblocks=1, txt='1block.txt', **kwargs)
df1NLFCx, df1LFCx = df1.get_dielectric_function(direction='x')
df1NLFCy, df1LFCy = df1.get_dielectric_function(direction='y')
df1NLFCz, df1LFCz = df1.get_dielectric_function(direction='z')
df2 = DielectricFunction('gs_Na.gpw', nblocks=4, txt='4block.txt', **kwargs)
df2NLFCx, df2LFCx = df2.get_dielectric_function(direction='x')
df2NLFCy, df2LFCy = df2.get_dielectric_function(direction='y')
df2NLFCz, df2LFCz = df2.get_dielectric_function(direction='z')
# Compare plasmon frequencies and intensities
w_w = df1.chi0.omega_w
w1, I1 = findpeak(w_w, -(1. / df1LFCx).imag)
from __future__ import print_function, division
import numpy as np
from gpaw.response.df import DielectricFunction
df = DielectricFunction('gs_MoS2.gpw',
frequencies=[0.5],
txt='eps_GG.txt',
hilbert=False,
ecut=50,
nbands=50)
df_t = DielectricFunction('gs_MoS2.gpw',
frequencies=[0.5],
txt='eps_GG.txt',
hilbert=False,
ecut=50,
nbands=50,
truncation='2D')
for iq in range(22):
pd, eps_wGG, chi_wGG = df.get_dielectric_matrix(q_c=[iq / 42, iq / 42, 0],
symmetric=False,
calculate_chi=True)
Gvec_Gv = pd.get_reciprocal_vectors(add_q=False)
epsinv_GG = np.linalg.inv(eps_wGG[0])
z0 = pd.gd.cell_cv[2, 2] / 2 # Center of layer
eps_t_wGG = df_t.get_dielectric_matrix(q_c=[iq / 42, iq / 42, 0],
symmetric=False)
epsinv_t_GG = np.linalg.inv(eps_t_wGG[0])
epsinv = 0.0
# Calculate the dielectric functions
dfs0 = [] # Arrays to check for self-consistency
dfs1 = []
dfs2 = []
dfs3 = []
dfs4 = []
dfs5 = []
for kwargs in settings:
try:
os.remove('chi0+0+0+0.pckl')
except OSError:
pass
df1 = DielectricFunction('gs_Na_small.gpw',
domega0=0.03,
omegamax=10,
ecut=150,
name='chi0',
**kwargs)
df1NLFCx, df1LFCx = df1.get_dielectric_function(direction='x')
df1NLFCy, df1LFCy = df1.get_dielectric_function(direction='y')
df1NLFCz, df1LFCz = df1.get_dielectric_function(direction='z')
try:
os.remove('chi1+0+0+0.pckl')
except OSError:
pass
df2 = DielectricFunction('gs_Na_large.gpw',
domega0=0.03,
omegamax=10,
calc.set(kpts=(20, 20, 7), fixdensity=True)
atoms.get_potential_energy()
# The result should also be converged with respect to bands:
calc.diagonalize_full_hamiltonian(nbands=60)
calc.write('graphite.gpw', 'all')
# Part 2: Spectra calculations
f = paropen('graphite_q_list', 'w') # write q
for i in range(1, 6): # loop over different q
df = DielectricFunction(
calc='graphite.gpw',
domega0=0.01,
eta=0.2, # Broadening parameter.
ecut=100,
# write different output for different q:
txt='out_df_%d.txt' % i)
q_c = [i / 20.0, 0.0, 0.0] # Gamma - M excitation
df.get_eels_spectrum(q_c=q_c, filename='graphite_EELS_%d' % i)
# Calculate cartesian momentum vector:
cell_cv = atoms.get_cell()
bcell_cv = 2 * np.pi * np.linalg.inv(cell_cv).T
q_v = np.dot(q_c, bcell_cv)
print(sqrt(np.inner(q_v, q_v)), file=f)
f.close()
valence_bands=range(4),
conduction_bands=range(4),
mode='RPA',
nbands=4,
ecut=ecut,
write_h=False,
write_v=False,
)
bse_w = bse.get_eels_spectrum(filename=None,
q_c=q_c,
w_w=w_w,
eta=eta)[1]
if df:
df = DielectricFunction(calc='Al.gpw',
frequencies=w_w,
eta=eta,
ecut=ecut,
hilbert=False)
df_w = df.get_eels_spectrum(q_c=q_c, filename=None)[1]
if check_spectrum:
w_ = 15.1423
I_ = 25.4359
wbse, Ibse = findpeak(w_w, bse_w)
wdf, Idf = findpeak(w_w, df_w)
equal(wbse, w_, 0.01)
equal(wdf, w_, 0.01)
equal(Ibse, I_, 0.1)
equal(Idf, I_, 0.1)
txt='large.txt')
a1.get_potential_energy()
a2.get_potential_energy()
# Use twice as many bands for expanded structure
a1.calc.diagonalize_full_hamiltonian(nbands=20)
a2.calc.diagonalize_full_hamiltonian(nbands=40)
a1.calc.write('gs_Na_small.gpw', 'all')
a2.calc.write('gs_Na_large.gpw', 'all')
# Calculate the dielectric functions
df1 = DielectricFunction('gs_Na_small.gpw',
omegamax=15,
domega0=0.05,
hilbert=True,
ecut=150)
df1NLFCx, df1LFCx = df1.get_dielectric_function(direction='x')
df1NLFCy, df1LFCy = df1.get_dielectric_function(direction='y')
df1NLFCz, df1LFCz = df1.get_dielectric_function(direction='z')
df2 = DielectricFunction('gs_Na_large.gpw',
omegamax=15,
domega0=0.05,
hilbert=True,
ecut=150)
df2NLFCx, df2LFCx = df2.get_dielectric_function(direction='x')
df2NLFCy, df2LFCy = df2.get_dielectric_function(direction='y')
calc = GPAW(mode='pw',
dtype=complex,
xc='RPBE',
nbands=16,
eigensolver='rmm-diis',
occupations=FermiDirac(0.01))
cluster.set_calculator(calc)
cluster.get_potential_energy()
calc.diagonalize_full_hamiltonian(nbands=24, scalapack=True)
calc.write('Au2.gpw', 'all')
if ABS:
df = DielectricFunction('Au2.gpw',
frequencies=np.linspace(0, 14, 141),
hilbert=not True,
eta=0.1,
ecut=10)
b0, b = df.get_dielectric_function(filename=None, direction='z')
a0, a = df.get_polarizability(filename=None, direction='z')
df_ws = DielectricFunction('Au2.gpw',
frequencies=np.linspace(0, 14, 141),
hilbert=not True,
eta=0.1,
ecut=10,
truncation='wigner-seitz')
a0_ws, a_ws = df_ws.get_polarizability(filename=None, direction='z')
w0_ = 5.60491055
import numpy as np
from ase.lattice import bulk
from gpaw import GPAW
from gpaw.response.df import DielectricFunction
# Part 1: Ground state calculation
atoms = bulk('Si', 'diamond',
a=5.431) # Generate diamond crystal structure for silicon
calc = GPAW(mode='pw', kpts=(4, 4, 4)) # GPAW calculator initialization
atoms.set_calculator(calc)
atoms.get_potential_energy() # Ground state calculation is performed
calc.write('si.gpw', 'all') # Use 'all' option to write wavefunction
# Part 2 : Spectrum calculation # DF: dielectric function object
df = DielectricFunction(
calc='si.gpw', # Ground state gpw file (with wavefunction) as input
domega0=0.05) # Using nonlinear frequency grid
df.get_dielectric_function() # By default, a file called 'df.csv' is generated
from gpaw.response.df import DielectricFunction
from gpaw.response.qeh import BuildingBlock
df = DielectricFunction(calc='WSe2_gs_fulldiag.gpw',
eta=0.001,
domega0=0.05,
omega2=10.0,
nblocks=8,
ecut=150,
name='WSe2_response_',
truncation='2D')
buildingblock = BuildingBlock('WSe2', df)
buildingblock.calculate_building_block()
from pathlib import Path
from gpaw.mpi import world
from gpaw.response.df import DielectricFunction
from gpaw.response.qeh import BuildingBlock
df = DielectricFunction(calc='MoS2_gs_fulldiag.gpw',
eta=0.001,
domega0=0.05,
omega2=10.0,
nblocks=8,
ecut=150,
truncation='2D')
buildingblock = BuildingBlock('MoS2', df, qmax=3.0)
buildingblock.calculate_building_block()
if world.rank == 0:
Path('MoS2_gs_fulldiag.gpw').unlink()
kpts = find_high_symmetry_monkhorst_pack('TaS2-gs.gpw', density=5.0)
responseGS = GPAW('TaS2-gs.gpw',
fixdensity=True,
kpts=kpts,
parallel={'band': 1},
nbands=60,
convergence={'bands': 50})
responseGS.get_potential_energy()
responseGS.write('TaS2-gsresponse.gpw', 'all')
# 3) Dielectric function
df = DielectricFunction('TaS2-gsresponse.gpw',
eta=25e-3,
domega0=0.01,
integrationmode='tetrahedron integration')
df1tetra_w, df2tetra_w = df.get_dielectric_function(direction='x')
df = DielectricFunction('TaS2-gsresponse.gpw', eta=25e-3, domega0=0.01)
df1_w, df2_w = df.get_dielectric_function(direction='x')
omega_w = df.get_frequencies()
if world.rank == 0:
plt.figure(figsize=(6, 6))
plt.plot(omega_w, df2tetra_w.real, label='tetra Re')
plt.plot(omega_w, df2tetra_w.imag, label='tetra Im')
plt.plot(omega_w, df2_w.real, label='Re')
plt.plot(omega_w, df2_w.imag, label='Im')
plt.xlabel('Frequency (eV)')
parallel={'band': 1},
idiotproof=False, # allow uneven distribution of k-points
xc='LDA')
atoms.set_calculator(calc)
atoms.get_potential_energy()
calc.write('Al', 'all')
t2 = time.time()
# Excited state calculation
q = np.array([1 / 4., 0., 0.])
w = np.linspace(0, 24, 241)
df = DielectricFunction(calc='Al',
frequencies=w,
eta=0.2,
ecut=50,
hilbert=False)
df.get_eels_spectrum(xc='ALDA', filename='EELS_Al_ALDA', q_c=q)
#df.check_sum_rule()
#df.write('Al.pckl')
t3 = time.time()
print('For ground state calc, it took', (t2 - t1) / 60, 'minutes')
print('For excited state calc, it took', (t3 - t2) / 60, 'minutes')
world.barrier()
d = np.loadtxt('EELS_Al_ALDA', delimiter=',')
# New results are compared with test values
wpeak1, Ipeak1 = findpeak(d[:, 0], d[:, 1])
a2.calc.diagonalize_full_hamiltonian(nbands=20)
a1.calc.write('intraband_spinpaired.gpw', 'all')
a2.calc.write('intraband_spinpolarized.gpw', 'all')
# Calculate the dielectric functions
if world.rank == 0:
try:
os.remove('intraband_spinpaired+0+0+0.pckl')
except OSError:
pass
df1 = DielectricFunction('intraband_spinpaired.gpw',
domega0=0.03,
ecut=10,
rate=0.1,
integrationmode='tetrahedron integration',
name='intraband_spinpaired',
txt='intraband_spinpaired_df.txt')
df1NLFCx, df1LFCx = df1.get_dielectric_function(direction='x')
df1NLFCy, df1LFCy = df1.get_dielectric_function(direction='y')
df1NLFCz, df1LFCz = df1.get_dielectric_function(direction='z')
wp1_vv = df1.chi0.plasmafreq_vv**0.5
wp1 = wp1_vv[0, 0]
if world.rank == 0:
try:
os.remove('intraband_spinpolarized+0+0+0.pckl')
except OSError:
pass
