def build_flow(options):
# Path of the pseudopotential to test.
#pseudo = data.pseudo("14si.pspnc")
pseudo = data.pseudo("Si.GGA_PBE-JTH-paw.xml")
# Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_")
workdir = options.workdir
if not options.workdir:
workdir = os.path.basename(__file__).replace(".py", "").replace("run_", "flow_")
# Initialize the flow.
flow = abilab.Flow(workdir=workdir, manager=options.manager, remove=options.remove)
# Build the workflow for the computation of the deltafactor.
# The calculation is done with the parameters and the cif files
# used in the original paper. We only have to specify
# the cutoff energy ecut (Ha) for the pseudopotential.
# The workflow will produce a pdf file with the equation of state
# and a file deltafactor.txt with the final results in the
# outdir directory DELTAFACTOR/work_0/outdir.
factory = DeltaFactory()
kppa = 6750 # Use this to have the official k-point sampling
kppa = 50 # this value is for testing purpose.
ecut = 8
pawecutdg = ecut * 2 if pseudo.ispaw else None
work = factory.work_for_pseudo(pseudo, accuracy="normal", kppa=kppa,
ecut=ecut, pawecutdg=pawecutdg,
toldfe=1.e-8, smearing="fermi_dirac:0.0005")
# Register the workflow.
flow.register_work(work)
return flow
def add_pseudo(self, pseudo):
"""Add a pseudo to the Dojo."""
pseudo = Pseudo.as_pseudo(pseudo)
dojo_report = pseudo.dojo_report
# Construct the flow
flow_workdir = os.path.join(self.workdir, pseudo.basename)
flow = Flow(workdir=flow_workdir, manager=self.manager)
# Construct the flow according to the info found in the dojo report.
if not pseudo.has_hints:
# We need the hints in order to run the other tests
factory = PPConvergenceFactory()
ecut_work = factory.work_for_pseudo(pseudo, ecut_slice=slice(4, None, 1), nlaunch=4)
flow.register_work(ecut_work)
else:
# Hints are available --> construct a flow for the different trials.
dojo_trial = "deltafactor"
if dojo_trial in self.trials:
# Do we have this element in the deltafactor database?
#if not df_database().has_symbol(pseudo.symbol):
# logger.warning("Cannot find %s in deltafactor database." % pseudo.symbol)
delta_factory = DeltaFactory()
kppa = 6750 # 6750 is the value used in the deltafactor code.
kppa = 1
for accuracy in self.accuracies:
if dojo_report.has_trial(dojo_trial, accuracy): continue
ecut, pawecutdg = self._ecut_pawecutdg(pseudo, accuracy)
work = delta_factory.work_for_pseudo(pseudo, accuracy=accuracy, kppa=kppa, ecut=ecut, pawecutdg=pawecutdg)
logger.info("Adding work for %s with accuracy %s" % (dojo_trial, accuracy))
work.set_dojo_accuracy(accuracy)
flow.register_work(work)
# Test if GBRV tests are wanted.
gbrv_structs = [s.split("_")[1] for s in self.trials if s.startswith("gbrv_")]
if gbrv_structs:
gbrv_factory = GbrvFactory()
for struct_type in gbrv_structs:
dojo_trial = "gbrv_" + struct_type
for accuracy in self.accuracies:
if dojo_report.has_trial(dojo_trial, accuracy): continue
ecut, pawecutdg = self._ecut_pawecutdg(pseudo, accuracy)
work = gbrv_factory.relax_and_eos_work(pseudo, struct_type, ecut=ecut, pawecutdg=pawecutdg)
logger.info("Adding work for %s with accuracy %s" % (dojo_trial, accuracy))
work.set_dojo_accuracy(accuracy)
flow.register_work(work)
flow.allocate()
self.pseudos.append(pseudo)
self.flows.append(flow)
def itest_deltafactor_gga_pawxml(fwp, tvars):
"""
Testing the flow used for the computation of the deltafactor with PAW and GGA XC.
"""
# Path of the pseudopotential to test.
pseudo = pdj_data.pseudo("Si.GGA_PBE-JTH-paw.xml").as_tmpfile(
tmpdir=fwp.workdir)
assert pseudo is not None
assert pseudo.has_dojo_report
assert not pseudo.dojo_report.exceptions
flow = abilab.Flow(workdir=fwp.workdir, manager=fwp.manager)
# Build the workflow for the computation of the deltafactor.
# The workflow will produce a pdf file with the equation of state
# and a file deltafactor.txt with the final results in the
# outdir directory DELTAFACTOR/work_0/outdir.
kppa = 20 # this value is for testing purpose (6570 is the correct one)
ecut = 2
pawecutdg = ecut * 2 if pseudo.ispaw else None
assert not pseudo.dojo_report.has_trial("deltafactor", ecut=ecut)
work = DeltaFactory(pseudo.xc).work_for_pseudo(pseudo,
kppa=kppa,
ecut=ecut,
pawecutdg=pawecutdg,
include_soc=False,
paral_kgb=tvars.paral_kgb)
# Register the workflow.
flow.register_work(work)
flow.build_and_pickle_dump(abivalidate=True)
for task in flow[0]:
task.start_and_wait()
flow.check_status(show=True)
assert flow.all_ok
assert all(work.finalized for work in flow)
results = flow[0].get_results()
#20.453 ang^3 88.545 GPa 4.31 20.8658081501 336.680999051 GPa -35.681897152
#delta Equation of State: deltafactor_polyfit
#Minimum volume = 20.87 Ang^3
#modulus = 2.10 eV/Ang^3 = 336.68 GPa, b1 = -35.68
#Deltafactor = 15.681 meV
assert pseudo.dojo_report.has_trial("deltafactor", ecut=ecut)
assert not pseudo.dojo_report.exceptions
def itest_deltafactor_gga_ncsoc(fwp, tvars):
"""
Testing the flow used for the computation of the deltafactor with GGA and NC+SOC.
"""
# return
# Path of the pseudopotential to test.
pseudo = pdj_data.pseudo("Pb-d-3_r.psp8").as_tmpfile(tmpdir=fwp.workdir)
assert pseudo.has_dojo_report
assert pseudo.supports_soc
assert not pseudo.dojo_report.exceptions
flow = abilab.Flow(workdir=fwp.workdir, manager=fwp.manager)
# Build the workflow for the computation of the deltafactor.
# The workflow will produce a pdf file with the equation of state
# and a file deltafactor.txt with the final results in the
# outdir directory DELTAFACTOR/work_0/outdir.
kppa = 40 # this value is for testing purpose (6570 is the correct one)
ecut = 8
pawecutdg = ecut * 2 if pseudo.ispaw else None
assert pseudo.dojo_report.has_trial("deltafactor", ecut=12)
assert not pseudo.dojo_report.has_trial("deltafactor_soc", ecut=ecut)
work = DeltaFactory(pseudo.xc).work_for_pseudo(pseudo,
kppa=kppa,
ecut=ecut,
pawecutdg=pawecutdg,
include_soc=True,
paral_kgb=tvars.paral_kgb)
# Register the workflow.
flow.register_work(work)
flow.build_and_pickle_dump(abivalidate=True)
for task in flow[0]:
task.start_and_wait()
flow.check_status(show=True)
assert flow.all_ok
assert all(work.finalized for work in flow)
results = flow[0].get_results()
assert pseudo.dojo_report.has_trial("deltafactor_soc", ecut=ecut)
assert not pseudo.dojo_report.exceptions
def itest_deltafactor(fwp, tvars):
"""Test the flow used for the computation of the deltafactor."""
# Path of the pseudopotential to test.
pseudo = abidata.pseudo("Si.GGA_PBE-JTH-paw.xml")
flow = abilab.Flow(workdir=fwp.workdir, manager=fwp.manager)
# Build the workflow for the computation of the deltafactor.
# The workflow will produce a pdf file with the equation of state
# and a file deltafactor.txt with the final results in the
# outdir directory DELTAFACTOR/work_0/outdir.
kppa = 20 # this value is for testing purpose (6570 is the correct one)
ecut = 2
pawecutdg = ecut * 2 if pseudo.ispaw else None
work = DeltaFactory().work_for_pseudo(pseudo,
kppa=kppa,
ecut=ecut,
pawecutdg=pawecutdg,
paral_kgb=tvars.paral_kgb)
# Register the workflow.
flow.register_work(work)
flow.allocate()
flow.build_and_pickle_dump()
for task in flow[0]:
task.start_and_wait()
flow.check_status()
flow.show_status()
assert flow.all_ok
assert all(work.finalized for work in flow)
results = flow[0].get_results()
def build_flow(pseudo, options):
"""Build the flow, returns None if no calculation must be performed."""
pseudo = Pseudo.as_pseudo(pseudo)
workdir = pseudo.basename + "_DOJO"
if os.path.exists(workdir):
warn("Directory %s already exists" % workdir)
return None
#raise ValueError("%s exists" % workdir)
flow = abilab.Flow(workdir=workdir, manager=options.manager)
extra_abivars = {
"mem_test": 0,
"fband": 2,
"nstep": 100,
"paral_kgb": options.paral_kgb
#"nsym": 1,
}
report = pseudo.read_dojo_report()
#print(report)
#hints = report["hints"]
# Build ecut mesh.
try:
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
except KeyError:
print('New pseudo without report from the generator, the convergence study is started from 16H')
report["ppgen_hints"] = {}
report["ppgen_hints"]["high"] = {}
report["ppgen_hints"]["high"]["ecut"] = 16.0
report["ecuts"] = [16.0, 20.0, 24.0]
pseudo.write_dojo_report(report)
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
#if 'extend' in options:
# next_ecut = max(ecut_list) + 2
# ecut_list.append(next_ecut)
#if 'new-ecut' in options:
# ecut_list.append(options['new-ecut'])
add_ecuts = False
if add_ecuts:
#dense_right = np.linspace(ppgen_ecut, ppgen_ecut + 10, num=6)
#dense_left = np.linspace(ppgen_ecut-8, ppgen_ecut, num=4, endpoint=False)
#coarse_high = np.linspace(ppgen_ecut + 15, ppgen_ecut + 40, num=4)
dense_right = np.arange(ppgen_ecut, ppgen_ecut + 6*2, step=2)
dense_left = np.arange(max(ppgen_ecut-6, 2), ppgen_ecut, step=2)
coarse_high = np.arange(ppgen_ecut + 15, ppgen_ecut + 35, step=5)
ecut_list = list(dense_left) + list(dense_right) + list(coarse_high)
# Computation of the deltafactor.
if "df" in options.trials:
#FIXME
#factory = DeltaFactory(xc=pseudo.xc)
if os.path.isfile('LDA'):
factory = DeltaFactory(xc='LDA')
else:
factory = DeltaFactory()
for ecut in ecut_list:
if "deltafactor" in report and ecut in report["deltafactor"].keys(): continue
pawecutdg = 2 * ecut if pseudo.ispaw else None
# Build and register the workflow.
work = factory.work_for_pseudo(pseudo, kppa=6750, ecut=ecut, pawecutdg=pawecutdg, **extra_abivars)
flow.register_work(work, workdir='WDF' + str(ecut))
# GBRV tests.
if "gbrv" in options.trials:
gbrv_factory = GbrvFactory()
gbrv_structs = ("fcc", "bcc")
for struct_type in gbrv_structs:
dojo_trial = "gbrv_" + struct_type
for ecut in ecut_list:
if dojo_trial in report and ecut in report[dojo_trial].keys(): continue
pawecutdg = 2 * ecut if pseudo.ispaw else None
# FIXME: we use ntime=3, because structure relaxations go bananas after the third step.
work = gbrv_factory.relax_and_eos_work(pseudo, struct_type, ecut=ecut, ntime=5, pawecutdg=pawecutdg, **extra_abivars)
flow.register_work(work, workdir="GBRV_" + struct_type + str(ecut))
# PHONON test
if "phonon" in options.trials:
phonon_factory = DFPTPhononFactory()
for ecut in ecut_list:
str_ecut = '%.1f' % ecut
if "phonon" in report and str_ecut in report["phonon"].keys(): continue
kppa = 1000
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = phonon_factory.work_for_pseudo(pseudo, accuracy="high", kppa=kppa, ecut=ecut, pawecutdg=pawecutdg,
tolwfr=1.e-20, smearing="fermi_dirac:0.0005", qpt=[0,0,0], mem_test=0)
if work is not None:
flow.register_work(work, workdir='GammaPhononsAt'+str(ecut))
else:
warn('cannot create GammaPhononsAt' + str(ecut) + ' work, factory returned None')
# PHONON WihtOut Asr test
if "phwoa" in options.trials:
phonon_factory = DFPTPhononFactory()
for ecut in [ecut_list[0], ecut_list[-1]]:
str_ecut = '%.1f' % ecut
if "phwoa" in report and str_ecut in report["phwoa"].keys(): continue
print('phwoa')
kppa = 1000
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = phonon_factory.work_for_pseudo(pseudo, accuracy="high", kppa=kppa, ecut=ecut, pawecutdg=pawecutdg,
tolwfr=1.e-20, smearing="fermi_dirac:0.0005", qpt=[0,0,0], rfasr=0)
if work is not None:
flow.register_work(work, workdir='GammaPhononsAt'+str(ecut)+'WOA')
else:
warn('cannot create GammaPhononsAt' + str(ecut) + 'WOA work, factory returned None')
if len(flow) > 0:
return flow.allocate()
else:
# Empty flow since all trials have been already performed.
return None
def build_flow(options):
# Path of the pseudopotential to test.
#pseudo = data.pseudo("14si.pspnc")
#pseudo = data.pseudo("Si.GGA_PBE-JTH-paw.xml")
here = os.path.abspath(os.path.curdir)
ps_name = options['name']
# the ocvpsps output file
pseudo = os.path.join(here, ps_name+".out")
print(pseudo)
with open(pseudo, 'r') as fi:
lines = fi.readlines()
fo = open(ps_name + '.psp8', 'w')
data = False
for line in lines:
if data:
fo.write(line)
if 'Begin PSPCODE8' in line:
data = True
fo.close()
pseudo = os.path.join(here, ps_name + '.psp8')
if options['strip']:
sys.exit()
# Instantiate the TaskManager.
manager = abilab.TaskManager.from_user_config()
# Build the workflow for the computation of the deltafactor.
# The calculation is done with the parameters and the cif files
# used in the original paper. We only have to specify
# the cutoff energy ecut (Ha) for the pseudopotential.
# The workflow will produce a pdf file with the equation of state
# and a file deltafactor.txt with the final results in the
# outdir directory DELTAFACTOR/Wnn/outdir.
if options['df']:
factory = DeltaFactory()
name = '_df'
elif options['phonon']:
factory = DFPTPhononFactory()
name = '_phon'
else:
print('no mode selected ...')
sys.exit()
#extra = {}
if options['test']:
workdir = ps_name+'_df_run_test'
flow = abilab.Flow(workdir=workdir, manager=manager, pickle_protocol=0)
kppa = 1000
ecut = 40
pawecutdg = ecut * 2
work = factory.work_for_pseudo(pseudo, accuracy="normal", kppa=kppa,
ecut=ecut, pawecutdg=pawecutdg,
toldfe=1.e-8, smearing="fermi_dirac:0.0005")
flow.register_work(work, workdir='W'+str(ecut))
else:
workdir = ps_name+'_df_run_full'
flow = abilab.Flow(workdir=workdir, manager=manager, pickle_protocol=0)
kppa = 6750 # Use this to have the official k-point sampling
for ecut in [12, 16, 20, 24, 28, 32, 36, 40, 44, 48]:
pawecutdg = ecut * 2
work = factory.work_for_pseudo(pseudo, accuracy="high", kppa=kppa,
ecut=ecut, pawecutdg=pawecutdg,
toldfe=1.e-10, smearing="fermi_dirac:0.0005")
#this needs to be done in the loop over ecut ...
flow.register_work(work, workdir='W'+str(ecut))
flow.allocate()
return flow.build_and_pickle_dump()
def build_flow(pseudo, options):
"""
Build the flow, returns None if the test has been already performed.
"""
print(pseudo)
if not pseudo.has_dojo_report:
raise ValueError("Cannot find dojo_report")
if options.soc and not pseudo.supports_soc:
raise TypeError(
"SOC is on but pseudo does not support spin-orbit coupling")
if not options.soc and pseudo.supports_soc and pseudo.path.endswith(
"psp8"):
cprint(
"[STRANGE]: Your psp8 pseudo supports SOC but options.soc is off",
"magenta")
report = pseudo.dojo_report
if options.verbose > 1: print(report)
workdir = pseudo.basename + "_DOJO" if options.workdir is None else options.workdir
if os.path.exists(workdir):
cprint("Directory %s already exists" % workdir, "red")
return None
flow = abilab.Flow(workdir=workdir, manager=options.manager)
extra_abivars = {
"mem_test": 0,
#"nstep": 100,
"paral_kgb": options.paral_kgb
}
#flow.walknset_vars(extra_abivars)
# Build ecut mesh.
try:
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
except KeyError:
cprint(
'New pseudo without report from the generator, the convergence study is started from 16H',
"yellow")
#raise NotImplementedError()
# TODO
#report = DojoReport.from_pseudo(pseudo)
report["ppgen_hints"] = {}
report["ppgen_hints"]["high"] = {}
report["ppgen_hints"]["high"]["ecut"] = 16.0
report["ecuts"] = [16.0, 20.0, 24.0]
report.json_write(pseudo.djrepo_path)
#pseudo.write_dojo_report(report)
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
try:
ecut_hint = int(report["hints"]["normal"]["ecut"])
except KeyError:
try:
ecut_hint = int(report["ppgen_hints"]["normal"]["ecut"])
except KeyError:
ecut_hint = ppgen_ecut
#if options.extend:
# next_ecut = max(ecut_list) + 2
# ecut_list.append(next_ecut)
#if options.new_ecut:
# ecut_list.append(options['new-ecut'])
add_ecuts = False
if add_ecuts:
#dense_right = np.linspace(ppgen_ecut, ppgen_ecut + 10, num=6)
#dense_left = np.linspace(ppgen_ecut-8, ppgen_ecut, num=4, endpoint=False)
#coarse_high = np.linspace(ppgen_ecut + 15, ppgen_ecut + 40, num=4)
dense_right = np.arange(ppgen_ecut, ppgen_ecut + 6 * 2, step=2)
dense_left = np.arange(max(ppgen_ecut - 6, 2), ppgen_ecut, step=2)
coarse_high = np.arange(ppgen_ecut + 15, ppgen_ecut + 35, step=5)
ecut_list = list(dense_left) + list(dense_right) + list(coarse_high)
# Computation of the deltafactor.
if "df" in options.trials or "deltafactor" in options.trials:
factory = DeltaFactory(xc=pseudo.xc)
dojo_trial = "deltafactor" if not options.soc else "deltafactor_soc"
#ecut_list = [75]
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint(
"[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT"
% (dojo_trial, ecut), "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = factory.work_for_pseudo(pseudo,
kppa=6750,
ecut=ecut,
pawecutdg=pawecutdg,
include_soc=options.soc,
**extra_abivars)
flow.register_work(work, workdir='WDF' + str(ecut))
# GBRV tests.
if "gbrv" in options.trials:
gbrv_factory = GbrvFactory(xc=pseudo.xc)
gbrv_structs = ("fcc", "bcc")
for struct_type in gbrv_structs:
dojo_trial = "gbrv_" + struct_type
if options.soc: dojo_trial += "_soc"
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint(
"[gbrv]: ignoring ecut=%s because it's already in the DOJO_REPORT"
% ecut, "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = gbrv_factory.relax_and_eos_work(pseudo,
struct_type,
ecut=ecut,
pawecutdg=pawecutdg,
include_soc=options.soc,
ntime=50,
**extra_abivars)
flow.register_work(work,
workdir="GBRV_" + struct_type + str(ecut))
# GHOSTS test
if "ghosts" in options.trials:
assert not options.soc
dojo_trial = "ghosts" if not options.soc else "ghosts_soc"
ghosts_factory = GhostsFactory(pseudo.xc)
ecut = int(report["ppgen_hints"]["high"]["ecut"])
pawecutdg = None if not pseudo.ispaw else int(
report["ppgen_hints"]["high"]["pawecutdg"])
#str_ecut = '%.1f' % ecut
#print(report["ghosts"].pop(ecut, None))
if report.has_trial(dojo_trial, ecut=ecut):
cprint(
"[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT"
% (dojo_trial, ecut), "magenta")
else:
# Build and register the work.
work = ghosts_factory.work_for_pseudo(pseudo,
kppa=2000,
maxene=250,
ecut=ecut,
pawecutdg=pawecutdg,
**extra_abivars)
if work is not None:
flow.register_work(work, workdir='GhostsAt' + str(ecut))
else:
cprint(
'Cannot create GhostsAt%s work, factory returned None' %
str(ecut), "magenta")
# phonons at gamma test.
if "phgamma" in options.trials:
phg_factory = GammaPhononFactory(pseudo.xc)
dojo_trial = "phgamma" if not options.soc else "phgamma_soc"
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint(
"[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT"
% (dojo_trial, ecut), "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = phg_factory.work_for_pseudo(pseudo,
kppa=1000,
ecut=ecut,
pawecutdg=pawecutdg,
include_soc=options.soc)
if work is not None:
flow.register_work(work)
else:
cprint(
'Cannot create phgamma work for ecut %s, factory returned None'
% str(ecut), "magenta")
if "raren_relax" in options.trials:
nirer_factory = RocksaltRelaxationFactory(pseudo.xc)
dojo_trial = "raren_relax" if not options.soc else "raren_relax_soc"
l = []
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint(
"[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT"
% (dojo_trial, ecut), "magenta")
continue
l.append(ecut)
ecut_list = l
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = nirer_factory.work_for_pseudo(pseudo,
ecut_list,
pawecutdg=pawecutdg,
include_soc=options.soc)
if work is not None:
flow.register_work(work)
else:
cprint('Cannot create nirer work, factory returned None',
"magenta")
if len(flow) > 0:
return flow.allocate()
else:
# Empty flow since all trials have been already performed.
return None
def build_flow(pseudo, options):
"""
Build the flow, returns None if the test has been already performed.
"""
print(pseudo)
if not pseudo.has_dojo_report:
raise ValueError("Cannot find dojo_report")
if options.soc and not pseudo.supports_soc:
raise TypeError("SOC is on but pseudo does not support spin-orbit coupling")
if not options.soc and pseudo.supports_soc and pseudo.path.endswith("psp8"):
cprint("[STRANGE]: Your psp8 pseudo supports SOC but options.soc is off", "magenta")
report = pseudo.dojo_report
if options.verbose > 1: print(report)
workdir = pseudo.basename + "_DOJO" if options.workdir is None else options.workdir
if os.path.exists(workdir):
cprint("Directory %s already exists" % workdir, "red")
return None
flow = abilab.Flow(workdir=workdir, manager=options.manager)
extra_abivars = {
"mem_test": 0,
#"nstep": 100,
"paral_kgb": options.paral_kgb
}
#flow.walknset_vars(extra_abivars)
# Build ecut mesh.
try:
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
except KeyError:
cprint('New pseudo without report from the generator, the convergence study is started from 16H', "yellow")
#raise NotImplementedError()
# TODO
#report = DojoReport.from_pseudo(pseudo)
report["ppgen_hints"] = {}
report["ppgen_hints"]["high"] = {}
report["ppgen_hints"]["high"]["ecut"] = 16.0
report["ecuts"] = [16.0, 20.0, 24.0]
report.json_write(pseudo.djrepo_path)
#pseudo.write_dojo_report(report)
ppgen_ecut = int(report["ppgen_hints"]["high"]["ecut"])
ecut_list = copy.copy(report["ecuts"])
try:
ecut_hint = int(report["hints"]["normal"]["ecut"])
except KeyError:
try:
ecut_hint = int(report["ppgen_hints"]["normal"]["ecut"])
except KeyError:
ecut_hint = ppgen_ecut
#if options.extend:
# next_ecut = max(ecut_list) + 2
# ecut_list.append(next_ecut)
#if options.new_ecut:
# ecut_list.append(options['new-ecut'])
add_ecuts = False
if add_ecuts:
#dense_right = np.linspace(ppgen_ecut, ppgen_ecut + 10, num=6)
#dense_left = np.linspace(ppgen_ecut-8, ppgen_ecut, num=4, endpoint=False)
#coarse_high = np.linspace(ppgen_ecut + 15, ppgen_ecut + 40, num=4)
dense_right = np.arange(ppgen_ecut, ppgen_ecut + 6*2, step=2)
dense_left = np.arange(max(ppgen_ecut-6, 2), ppgen_ecut, step=2)
coarse_high = np.arange(ppgen_ecut + 15, ppgen_ecut + 35, step=5)
ecut_list = list(dense_left) + list(dense_right) + list(coarse_high)
# Computation of the deltafactor.
if "df" in options.trials or "deltafactor" in options.trials:
factory = DeltaFactory(xc=pseudo.xc)
dojo_trial = "deltafactor" if not options.soc else "deltafactor_soc"
#ecut_list = [75]
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint("[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT" % (dojo_trial, ecut), "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = factory.work_for_pseudo(pseudo, kppa=6750, ecut=ecut, pawecutdg=pawecutdg,
include_soc=options.soc, **extra_abivars)
flow.register_work(work, workdir='WDF' + str(ecut))
# GBRV tests.
if "gbrv" in options.trials:
gbrv_factory = GbrvFactory(xc=pseudo.xc)
gbrv_structs = ("fcc", "bcc")
for struct_type in gbrv_structs:
dojo_trial = "gbrv_" + struct_type
if options.soc: dojo_trial += "_soc"
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint("[gbrv]: ignoring ecut=%s because it's already in the DOJO_REPORT" % ecut, "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = gbrv_factory.relax_and_eos_work(pseudo, struct_type, ecut=ecut, pawecutdg=pawecutdg,
include_soc=options.soc, ntime=50, **extra_abivars)
flow.register_work(work, workdir="GBRV_" + struct_type + str(ecut))
# GHOSTS test
if "ghosts" in options.trials:
assert not options.soc
dojo_trial = "ghosts" if not options.soc else "ghosts_soc"
ghosts_factory = GhostsFactory(pseudo.xc)
ecut = int(report["ppgen_hints"]["high"]["ecut"])
pawecutdg = None if not pseudo.ispaw else int(report["ppgen_hints"]["high"]["pawecutdg"])
#str_ecut = '%.1f' % ecut
#print(report["ghosts"].pop(ecut, None))
if report.has_trial(dojo_trial, ecut=ecut):
cprint("[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT" % (dojo_trial, ecut), "magenta")
else:
# Build and register the work.
work = ghosts_factory.work_for_pseudo(pseudo, kppa=2000, maxene=250,
ecut=ecut, pawecutdg=pawecutdg,
**extra_abivars)
if work is not None:
flow.register_work(work, workdir='GhostsAt' + str(ecut))
else:
cprint('Cannot create GhostsAt%s work, factory returned None' % str(ecut), "magenta")
# phonons at gamma test.
if "phgamma" in options.trials:
phg_factory = GammaPhononFactory(pseudo.xc)
dojo_trial = "phgamma" if not options.soc else "phgamma_soc"
for ecut in ecut_list:
if report.has_trial(dojo_trial, ecut=ecut):
cprint("[%s]: ignoring ecut=%s because it's already in the DOJO_REPORT" % (dojo_trial, ecut), "magenta")
continue
# Build and register the work.
pawecutdg = 2 * ecut if pseudo.ispaw else None
work = phg_factory.work_for_pseudo(pseudo, kppa=1000, ecut=ecut, pawecutdg=pawecutdg,
include_soc=options.soc)
if work is not None:
flow.register_work(work)
else:
cprint('Cannot create phgamma work for ecut %s, factory returned None' % str(ecut), "magenta")
if len(flow) > 0:
return flow.allocate()
else:
# Empty flow since all trials have been already performed.
return None
