def test_read_extra_abivars(self):
vars_out = {'ecut': 40}
f = open('extra_abivars', 'w')
f.write(str(vars_out))
f.close()
vars_in = read_extra_abivars()
self.assertEqual(vars_out, vars_in)
os.remove('extra_abivars')
def test_read_extra_abivars(self):
"""
Testing helper function to read extra variables
"""
vars_out = {'ecut': 40}
f = open('extra_abivars', 'w')
f.write(str(vars_out))
f.close()
vars_in = read_extra_abivars()
self.assertEqual(vars_out, vars_in)
os.remove('extra_abivars')
def test_read_extra_abivars(self):
"""
Testing helper function to read extra variables
"""
vars_out = {'ecut': 40}
f = open('extra_abivars', 'w')
f.write(str(vars_out))
f.close()
vars_in = read_extra_abivars()
self.assertEqual(vars_out, vars_in)
os.remove('extra_abivars')
def create(self):
"""
create single abinit G0W0 flow
"""
# manager = 'slurm' if 'ceci' in self.spec['mode'] else 'shell'
# an AbiStructure object has an overwritten version of get_sorted_structure that sorts according to Z
# this could also be pulled into the constructor of Abistructure
# abi_structure = self.structure.get_sorted_structure()
from abipy import abilab
item = copy.copy(self.structure.item)
self.structure.__class__ = abilab.Structure
self.structure = self.structure.get_sorted_structure_z()
self.structure.item = item
abi_structure = self.structure
manager = TaskManager.from_user_config()
# Initialize the flow.
flow = Flow(self.work_dir, manager, pickle_protocol=0)
# flow = Flow(self.work_dir, manager)
# kpoint grid defined over density 40 > ~ 3 3 3
if self.spec['converge'] and not self.all_converged:
# (2x2x2) gamma centered mesh for the convergence test on nbands and ecuteps
# if kp_in is present in the specs a kp_in X kp_in x kp_in mesh is used for the convergence study
if 'kp_in' in self.spec.data.keys():
if self.spec['kp_in'] > 9:
print('WARNING:\nkp_in should be < 13 to generate an n x n x n mesh\nfor larger values a grid with '
'density kp_in will be generated')
kppa = self.spec['kp_in']
else:
kppa = 2
else:
# use the specified density for the final calculation with the converged nbands and ecuteps of other
# stand alone calculations
kppa = self.spec['kp_grid_dens']
gamma = True
# 'standard' parameters for stand alone calculation
scf_nband = self.get_bands(self.structure) + 20
# additional bands to accommodate for nbdbuf and a bit extra
nscf_nband = [10 * self.get_bands(self.structure)]
nksmall = None
ecuteps = [8]
extra_abivars = dict()
# read user defined extra abivars from file 'extra_abivars' should be dictionary
extra_abivars.update(read_extra_abivars())
# self.bands_fac = 0.5 if 'gwcomp' in extra_abivars.keys() else 1
# self.convs['nscf_nbands']['test_range'] =
# tuple([self.bands_fac*x for x in self.convs['nscf_nbands']['test_range']])
ecut = extra_abivars.pop('ecut', 44)
ecutsigx = extra_abivars.pop('ecutsigx', 44)
if ecutsigx > ecut:
raise RuntimeError('ecutsigx can not be largen than ecut')
if ecutsigx < max(ecuteps):
raise RuntimeError('ecutsigx < ecuteps this is not realistic')
response_models = ['godby']
if 'ppmodel' in extra_abivars.keys():
response_models = [extra_abivars.pop('ppmodel')]
if self.option is not None:
for k in self.option.keys():
if k == 'ecut':
ecut = self.option[k]
if k in ['ecuteps', 'nscf_nbands']:
pass
else:
extra_abivars.update({k: self.option[k]})
try:
grid = read_grid_from_file(s_name(self.structure)+".full_res")['grid']
all_done = read_grid_from_file(s_name(self.structure)+".full_res")['all_done']
workdir = os.path.join(s_name(self.structure), 'w'+str(grid))
except (IOError, OSError):
grid = 0
all_done = False
workdir = None
if not all_done:
if (self.spec['test'] or self.spec['converge']) and not self.all_converged:
if self.spec['test']:
print('| setting test calculation')
tests = SingleAbinitGWWork(self.structure, self.spec).tests
response_models = []
else:
if grid == 0:
print('| setting convergence calculations for grid 0')
# tests = SingleAbinitGWWorkFlow(self.structure, self.spec).convs
tests = self.convs
else:
print('| extending grid')
# tests = expand(SingleAbinitGWWorkFlow(self.structure, self.spec).convs, grid)
tests = expand(self.convs, grid)
ecuteps = []
nscf_nband = []
for test in tests:
if tests[test]['level'] == 'scf':
if self.option is None:
extra_abivars.update({test + '_s': tests[test]['test_range']})
elif test in self.option:
extra_abivars.update({test: self.option[test]})
else:
extra_abivars.update({test + '_s': tests[test]['test_range']})
else:
for value in tests[test]['test_range']:
if test == 'nscf_nbands':
nscf_nband.append(value * self.get_bands(self.structure))
# scr_nband takes nscf_nbands if not specified
# sigma_nband takes scr_nbands if not specified
if test == 'ecuteps':
ecuteps.append(value)
if test == 'response_model':
response_models.append(value)
elif self.all_converged:
print('| setting up for testing the converged values at the high kp grid ')
# add a bandstructure and dos calculation
if os.path.isfile('bands'):
nksmall = -30
# negative value > only bandstructure
else:
nksmall = 30
# in this case a convergence study has already been performed.
# The resulting parameters are passed as option
ecuteps = [self.option['ecuteps'], self.option['ecuteps'] + self.convs['ecuteps']['test_range'][1] -
self.convs['ecuteps']['test_range'][0]]
nscf_nband = [self.option['nscf_nbands'], self.option['nscf_nbands'] + self.convs['nscf_nbands'][
'test_range'][1] - self.convs['nscf_nbands']['test_range'][0]]
# for option in self.option:
# if option not in ['ecuteps', 'nscf_nband']:
# extra_abivars.update({option + '_s': self.option[option]})
else:
print('| all is done for this material')
return
logger.info('ecuteps : %s ' % str(ecuteps))
logger.info('extra : %s ' % str(extra_abivars))
logger.info('nscf_nb : %s ' % str(nscf_nband))
inputs = g0w0_convergence_inputs(abi_structure, self.pseudo_table, kppa, nscf_nband, ecuteps, ecutsigx,
scf_nband, ecut, accuracy="normal", spin_mode="unpolarized", smearing=None,
response_models=response_models, charge=0.0, sigma_nband=None, scr_nband=None,
gamma=gamma, nksmall=nksmall, extra_abivars=extra_abivars)
work = G0W0Work(scf_inputs=inputs[0], nscf_inputs=inputs[1], scr_inputs=inputs[2], sigma_inputs=inputs[3])
# work = g0w0_extended_work(abi_structure, self.pseudo_table, kppa, nscf_nband, ecuteps, ecutsigx, scf_nband,
# accuracy="normal", spin_mode="unpolarized", smearing=None, response_models=response_models,
# charge=0.0, sigma_nband=None, scr_nband=None, gamma=gamma, nksmall=nksmall, **extra_abivars)
print(workdir)
flow.register_work(work, workdir=workdir)
return flow.allocate()
def process_data(self, structure):
"""
Process the data of a set of GW calculations:
for 'single' and 'test' calculations the data is read and outputted
for the parameter scanning part of a convergence calculation the data is read and parameters that provide
converged results are determined
for the 'full' part of a convergence calculation the data is read and it is tested if the slopes are in
agreement with the scanning part
"""
data = GWConvergenceData(spec=self, structure=structure)
if self.data["converge"]:
done = False
try:
data.read_full_res_from_file()
if data.full_res["all_done"]:
done = True
print("| no action needed al is done already")
except (IOError, OSError, SyntaxError):
pass
data.set_type()
while not done:
if data.type["parm_scr"]:
data.read()
if len(data.data) == 0:
print("| parm_scr type calculation but no data found.")
break
if len(data.data) < 9: # todo this should be calculated
print(
"| parm_scr type calculation but no complete data found,"
" check if all calculations are done."
)
break
if data.find_conv_pars_scf("ecut", "full_width", self["tol"])[0]:
print("| parm_scr type calculation, converged scf values found")
else:
print("| parm_scr type calculation, no converged scf values found")
data.full_res.update({"remark": "No converged SCf parameter found. Continue anyway."})
data.conv_res["values"].update({"ecut": 40 * eV_to_Ha})
data.conv_res["control"].update({"ecut": True})
# if ecut is provided in extra_abivars overwrite in any case ..
if "ecut" in read_extra_abivars().keys():
data.conv_res["values"].update({"ecut": read_extra_abivars()["ecut"] * eV_to_Ha})
# if converged ok, if not increase the grid parameter of the next set of calculations
extrapolated = data.find_conv_pars(self["tol"])
if data.conv_res["control"]["nbands"]:
print(
"| parm_scr type calculation, converged values found, extrapolated value: %s"
% extrapolated[4]
)
else:
print("| parm_scr type calculation, no converged values found, increasing grid")
data.full_res["grid"] += 1
data.print_full_res()
data.print_conv_res()
# plot data:
print_gnuplot_header("plots", s_name(structure) + " tol = " + str(self["tol"]), filetype=None)
data.print_gnuplot_line("plots")
data.print_plot_data()
done = True
elif data.type["full"]:
if not data.read_conv_res_from_file(s_name(structure) + ".conv_res"):
print("| Full type calculation but the conv_res file is not available, trying to reconstruct")
data.read()
data.find_conv_pars(self["tol"])
data.print_conv_res()
data.read(subset=".conv")
if len(data.data) == 0:
print("| Full type calculation but no data found.")
break
if len(data.data) < 4:
print("| Full type calculation but no complete data found.")
for item in data.data:
print(item)
break
if data.test_full_kp_results(tol_rel=1, tol_abs=0.0015):
print(
"| Full type calculation and the full results agree with the parm_scr."
" All_done for this compound."
)
data.full_res.update({"all_done": True})
data.print_full_res()
done = True
# data.print_plot_data()
self.code_interface.store_results(name=s_name(structure))
else:
print("| Full type calculation but the full results do not agree with the parm_scr.")
print("| Increase the tol to find better converged parameters and test the full grid again.")
print("| TODO")
data.full_res.update({"remark": "no agreement at high dens kp mesh,", "all_done": True})
# read the system specific tol for System.conv_res
# if it's not there create it from the global tol
# reduce tol
# set data.type to convergence
# loop
done = True
elif self.data["test"]:
data.read()
data.set_type()
data.print_plot_data()
else:
data.read()
data.set_type()
data.print_plot_data()
def create(self):
"""
create single abinit G0W0 flow
"""
# manager = 'slurm' if 'ceci' in self.spec['mode'] else 'shell'
# an AbiStructure object has an overwritten version of get_sorted_structure that sorts according to Z
# this could also be pulled into the constructor of Abistructure
# abi_structure = self.structure.get_sorted_structure()
from abipy import abilab
item = copy.copy(self.structure.item)
self.structure.__class__ = abilab.Structure
self.structure = self.structure.get_sorted_structure_z()
self.structure.item = item
abi_structure = self.structure
manager = TaskManager.from_user_config()
# Initialize the flow.
flow = Flow(self.work_dir, manager, pickle_protocol=0)
# flow = Flow(self.work_dir, manager)
# kpoint grid defined over density 40 > ~ 3 3 3
if self.spec['converge'] and not self.all_converged:
# (2x2x2) gamma centered mesh for the convergence test on nbands and ecuteps
# if kp_in is present in the specs a kp_in X kp_in x kp_in mesh is used for the convergence study
if 'kp_in' in self.spec.data.keys():
if self.spec['kp_in'] > 9:
print(
'WARNING:\nkp_in should be < 13 to generate an n x n x n mesh\nfor larger values a grid with '
'density kp_in will be generated')
kppa = self.spec['kp_in']
else:
kppa = 2
else:
# use the specified density for the final calculation with the converged nbands and ecuteps of other
# stand alone calculations
kppa = self.spec['kp_grid_dens']
gamma = True
# 'standard' parameters for stand alone calculation
scf_nband = self.get_bands(self.structure) + 20
# additional bands to accommodate for nbdbuf and a bit extra
nscf_nband = [10 * self.get_bands(self.structure)]
nksmall = None
ecuteps = [8]
extra_abivars = dict()
# read user defined extra abivars from file 'extra_abivars' should be dictionary
extra_abivars.update(read_extra_abivars())
# self.bands_fac = 0.5 if 'gwcomp' in extra_abivars.keys() else 1
# self.convs['nscf_nbands']['test_range'] =
# tuple([self.bands_fac*x for x in self.convs['nscf_nbands']['test_range']])
ecut = extra_abivars.pop('ecut', 44)
ecutsigx = extra_abivars.pop('ecutsigx', 44)
if ecutsigx > ecut:
raise RuntimeError('ecutsigx can not be largen than ecut')
if ecutsigx < max(ecuteps):
raise RuntimeError('ecutsigx < ecuteps this is not realistic')
response_models = ['godby']
if 'ppmodel' in extra_abivars.keys():
response_models = [extra_abivars.pop('ppmodel')]
if self.option is not None:
for k in self.option.keys():
if k == 'ecut':
ecut = self.option[k]
if k in ['ecuteps', 'nscf_nbands']:
pass
else:
extra_abivars.update({k: self.option[k]})
try:
grid = read_grid_from_file(s_name(self.structure) +
".full_res")['grid']
all_done = read_grid_from_file(
s_name(self.structure) + ".full_res")['all_done']
workdir = os.path.join(s_name(self.structure), 'w' + str(grid))
except (IOError, OSError):
grid = 0
all_done = False
workdir = None
if not all_done:
if (self.spec['test']
or self.spec['converge']) and not self.all_converged:
if self.spec['test']:
print('| setting test calculation')
tests = SingleAbinitGWWork(self.structure, self.spec).tests
response_models = []
else:
if grid == 0:
print('| setting convergence calculations for grid 0')
# tests = SingleAbinitGWWorkFlow(self.structure, self.spec).convs
tests = self.convs
else:
print('| extending grid')
# tests = expand(SingleAbinitGWWorkFlow(self.structure, self.spec).convs, grid)
tests = expand(self.convs, grid)
ecuteps = []
nscf_nband = []
for test in tests:
if tests[test]['level'] == 'scf':
if self.option is None:
extra_abivars.update(
{test + '_s': tests[test]['test_range']})
elif test in self.option:
extra_abivars.update({test: self.option[test]})
else:
extra_abivars.update(
{test + '_s': tests[test]['test_range']})
else:
for value in tests[test]['test_range']:
if test == 'nscf_nbands':
nscf_nband.append(
value * self.get_bands(self.structure))
# scr_nband takes nscf_nbands if not specified
# sigma_nband takes scr_nbands if not specified
if test == 'ecuteps':
ecuteps.append(value)
if test == 'response_model':
response_models.append(value)
elif self.all_converged:
print(
'| setting up for testing the converged values at the high kp grid '
)
# add a bandstructure and dos calculation
if os.path.isfile('bands'):
nksmall = -30
# negative value > only bandstructure
else:
nksmall = 30
# in this case a convergence study has already been performed.
# The resulting parameters are passed as option
ecuteps = [
self.option['ecuteps'], self.option['ecuteps'] +
self.convs['ecuteps']['test_range'][1] -
self.convs['ecuteps']['test_range'][0]
]
nscf_nband = [
self.option['nscf_nbands'], self.option['nscf_nbands'] +
self.convs['nscf_nbands']['test_range'][1] -
self.convs['nscf_nbands']['test_range'][0]
]
# for option in self.option:
# if option not in ['ecuteps', 'nscf_nband']:
# extra_abivars.update({option + '_s': self.option[option]})
else:
print('| all is done for this material')
return
logger.info('ecuteps : %s ' % str(ecuteps))
logger.info('extra : %s ' % str(extra_abivars))
logger.info('nscf_nb : %s ' % str(nscf_nband))
inputs = g0w0_convergence_inputs(abi_structure,
self.pseudo_table,
kppa,
nscf_nband,
ecuteps,
ecutsigx,
scf_nband,
ecut,
accuracy="normal",
spin_mode="unpolarized",
smearing=None,
response_models=response_models,
charge=0.0,
sigma_nband=None,
scr_nband=None,
gamma=gamma,
nksmall=nksmall,
extra_abivars=extra_abivars)
work = G0W0Work(scf_inputs=inputs[0],
nscf_inputs=inputs[1],
scr_inputs=inputs[2],
sigma_inputs=inputs[3])
# work = g0w0_extended_work(abi_structure, self.pseudo_table, kppa, nscf_nband, ecuteps, ecutsigx, scf_nband,
# accuracy="normal", spin_mode="unpolarized", smearing=None, response_models=response_models,
# charge=0.0, sigma_nband=None, scr_nband=None, gamma=gamma, nksmall=nksmall, **extra_abivars)
print(workdir)
flow.register_work(work, workdir=workdir)
return flow.allocate()
