def build_flow(options):
gs_inp, ph_inp = make_inputs()
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
gs_work = abilab.Work()
gs_work.register_scf_task(gs_inp)
flow.register_work(gs_work)
flow.exclude_from_benchmark(gs_work)
# Get the list of possible parallel configurations from abinit autoparal.
max_ncpus, min_eff = options.max_ncpus, options.min_eff
print("Getting all autoparal confs up to max_ncpus: ", max_ncpus,
" with efficiency >= ", min_eff)
pconfs = ph_inp.abiget_autoparal_pconfs(max_ncpus, autoparal=1)
print(pconfs)
work = abilab.Work()
for conf, omp_threads in product(pconfs, options.omp_list):
if not options.accept_conf(conf, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
conf.mpi_procs, omp_threads)
inp = ph_inp.new_with_vars(conf.vars)
work.register_phonon_task(inp,
manager=manager,
deps={gs_work[0]: "WFK"})
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def bse_benchmark(options):
"""
Build an `AbinitWorkflow` used for benchmarking ABINIT.
"""
gs_inp, bse_inp = make_inputs(paw=options.paw)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
gs_work = abilab.Work()
gs_work.register_scf_task(gs_inp)
flow.register_work(gs_work)
flow.exclude_from_benchmark(gs_work)
mpi_list = options.mpi_list
if options.mpi_list is None:
nkpt = len(gs_inp.abiget_ibz().points)
ntrans = (2 * 2 * nkpt)**2
mpi_list = [p for p in range(1, 1 + ntrans) if ntrans % p == 0]
print("Using mpi_list:", mpi_list)
bse_work = abilab.Work()
for mpi_procs, omp_threads in product(mpi_list, options.omp_list):
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
bse_work.register_bse_task(bse_inp,
manager=manager,
deps={gs_work[0]: "WFK"})
flow.register_work(bse_work)
return flow.allocate()
def itest_dilatmx_error_handler(fwp, tvars):
"""
Test cell relaxation with automatic restart in the presence of dilatmx error.
"""
# Build the flow
flow = abilab.Flow(fwp.workdir, manager=fwp.manager)
# Decrease the volume to trigger DilatmxError
ion_input, ioncell_input = make_ion_ioncell_inputs(tvars,
dilatmx=1.01,
scalevol=0.8)
work = abilab.Work()
work.register_relax_task(ioncell_input)
flow.register_work(work)
flow.allocate()
assert flow.make_scheduler().start() == 0
flow.show_status()
assert all(work.finalized for work in flow)
assert flow.all_ok
# t0 should have reached S_OK, and we should have DilatmxError in the corrections.
t0 = work[0]
assert t0.status == t0.S_OK
print(t0.corrections)
assert t0.num_corrections == 1
assert t0.corrections[0]["event"]["@class"] == "DilatmxError"
def scr_benchmark(options):
"""
Build an `AbinitWorkflow` used for benchmarking ABINIT.
"""
gs_inp, nscf_inp, scr_inp = make_inputs(paw=options.paw)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
bands = abilab.BandStructureWork(gs_inp, nscf_inp)
flow.register_work(bands)
flow.exclude_from_benchmark(bands)
print("Using mpi_list:", options.mpi_list)
mpi_list = options.mpi_list
for nband in [200, 400, 600]:
scr_work = abilab.Work()
if options.mpi_list is None:
# Cannot call autoparal here because we need a WFK file.
print("Using hard coded values for mpi_list")
mpi_list = [
np for np in range(1, nband + 1) if abs((nband - 28) % np) < 1
]
print("Using nband %d and mpi_list: %s" % (nband, mpi_list))
for mpi_procs, omp_threads in product(mpi_list, options.omp_list):
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
scr_work.register_scr_task(scr_inp,
manager=manager,
deps={bands.nscf_task: "WFK"})
flow.register_work(scr_work)
return flow.allocate()
def build_flow(options):
flow = BenchmarkFlow(workdir=options.get_workdir(__file__), remove=options.remove)
template = make_input()
# Processor distribution.
pconfs = [
dict(npkpt=1, npband=13, npfft=10), # 130
dict(npkpt=1, npband=26, npfft=10), # 260
dict(npkpt=1, npband=65, npfft=8 ), # 520
dict(npkpt=1, npband=65, npfft=16), # 1040
]
for wfoptalg in [None, 1]:
work = abilab.Work()
for d, omp_threads in product(pconfs, options.omp_list):
mpi_procs = reduce(operator.mul, d.values(), 1)
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(mpi_procs, omp_threads)
print("wfoptalg:", wfoptalg, "done with MPI_PROCS:", mpi_procs, "and:", d)
inp = template.new_with_vars(d, wfoptalg=wfoptalg)
work.register_scf_task(inp, manager=manager)
flow.register_work(work)
return flow.allocate()
def build_flow(options):
template = make_input()
# Get the list of possible parallel configurations from abinit autoparal.
max_ncpus, min_eff = options.max_ncpus, options.min_eff
print("Getting all autoparal confs up to max_ncpus: ", max_ncpus,
" with efficiency >= ", min_eff)
pconfs = template.abiget_autoparal_pconfs(max_ncpus,
autoparal=1,
verbose=options.verbose)
if options.verbose: print(pconfs)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
omp_threads = 1
for accesswff in [1, 3]: # [MPI-IO, Netcdf]
work = abilab.Work()
for conf in pconfs:
mpi_procs = conf.mpi_ncpus
omp_threads = conf.omp_ncpus
if not options.accept_conf(conf, omp_threads): continue
# Two GS-SCF tasks. The first one produces the WKF, the second one reads it.
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
inp = template.new_with_vars(conf.vars, accesswff=accesswff)
task0 = work.register_scf_task(inp, manager=manager)
work.register_scf_task(inp, manager=manager, deps={task0: "WFK"})
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def build_flow(options):
# 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_")
# Create the flow
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
# Create a relaxation work and add it to the flow.
ion_inp, ioncell_inp = make_ion_ioncell_inputs()
relax_work = abilab.RelaxWork(ion_inp, ioncell_inp)
flow.register_work(relax_work)
#bands_work = abilab.BandStructureWork(scf_input, nscf_input)
bands_work = abilab.Work()
deps = {relax_work[-1]: "@structure"}
deps = {relax_work[-1]: ["DEN", "@structure"]} # --> This is not possible because the file ext is changed!
#deps = {relax_work[-1]: ["WFK", "@structure"]} # --> This triggers an infamous bug in abinit
bands_work.register_relax_task(ioncell_inp, deps=deps)
flow.register_work(bands_work)
return flow
def build_flow(options):
template = make_input()
# Get the list of possible parallel configurations from abinit autoparal.
max_ncpus, min_eff = options.max_ncpus, options.min_eff
print("Getting all autoparal confs up to max_ncpus: ",max_ncpus," with efficiency >= ",min_eff)
pconfs = template.abiget_autoparal_pconfs(max_ncpus, autoparal=1, verbose=options.verbose)
if options.verbose: print(pconfs)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__), remove=options.remove)
omp_threads = 1
for istwfk in [1, 2]:
work = abilab.Work()
for conf in pconfs:
mpi_procs = conf.mpi_ncpus
if not options.accept_conf(conf, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(mpi_procs, omp_threads)
inp = template.new_with_vars(conf.vars, istwfk=istwfk)
work.register_scf_task(inp, manager=manager)
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def build_flow(options):
fftalg_list = [312, 402, 401]
ecut_list = list(range(200, 610, 100))
ecut_list = [
400,
]
if options.mpi_list is None: mpi_list = [2, 4, 6, 8]
print("Using mpi_list:", mpi_list)
template = make_input()
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
omp_threads = 1
for fftalg in fftalg_list:
work = abilab.Work()
for npfft in mpi_list:
if not options.accept_mpi_omp(npfft, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
npfft, omp_threads)
for inp in abilab.input_gen(template,
fftalg=fftalg,
npfft=npfft,
ecut=ecut_list):
work.register_scf_task(inp, manager=manager)
flow.register_work(work)
return flow.allocate()
def build_flow(options):
template = make_input()
# Get the list of possible parallel configurations from abinit autoparal.
#max_ncpus, min_eff = options.max_ncpus, options.min_eff
#print("Getting all autoparal configurations up to max_ncpus: ",max_ncpus," with efficiency >= ",min_eff)
#pconfs = template.abiget_autoparal_pconfs(max_ncpus, autoparal=1, verbose=options.verbose)
#if options.verbose: print(pconfs)
# Processor distribution.
pconfs = [
dict(npkpt=64, npband=1, npfft=2), # 128
dict(npkpt=64, npband=2, npfft=2), # 256
dict(npkpt=64, npband=2, npfft=4), # 512
dict(npkpt=64, npband=4, npfft=4), # 1024
]
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
for wfoptalg in [None, 1]:
work = abilab.Work()
for conf, omp_threads in product(pconfs, options.omp_list):
#if not options.accept_conf(conf, omp_threads): continue
mpi_procs = omp_threads * reduce(operator.mul, conf.values(), 1)
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
inp = template.new_with_vars(conf, wfoptalg=wfoptalg)
work.register_scf_task(inp, manager=manager)
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def raman_flow():
# Get the unperturbed structure.
base_structure = abilab.Structure.from_abivars(unit_cell)
pseudos = ["14si.pspnc"]
workdir = os.path.join(os.path.dirname(__file__), "test_abipy_new")
manager = abilab.TaskManager.from_user_config()
#manager = abilab.TaskManager.from_file("bfo_manager.yml")
policy = TaskPolicy(autoparal=0)
gs_manager = manager.deepcopy()
# Initialize flow. Each workflow in the flow defines a complete BSE calculation for given eta.
flow = abilab.Flow(workdir, manager)
# There will be kppa/natom kpoints in the unit cell !
kppa = 3456 # ngkpt = [12,12,12] for the primitive cell
kppa_gs = 1728 # ngkpt = [8,8,8] for the primitive cell
etas = [-1, 0, 1] # Anyway, it rescales everything at the end :-)
eta = 0.01
scale_matrix = [[-1, 0, 1], [-1, 1, 0], [-1, -1, 0]]
ph_tot = np.array([[0.01, 0.011, 0.021], [-0.01, 0.041, -0.02]])
modifier = abilab.StructureModifier(base_structure)
displaced_structure = modifier.frozen_phonon([0.5, 0.5, 0.5],
ph_tot,
do_real=True,
frac_coords=False,
scale_matrix=scale_matrix)
structure = displaced_structure
ksampgs = KSampling.automatic_density(structure,
kppa_gs,
chksymbreak=0,
shifts=[0, 0, 0])
gs_inp = gs_input(structure, pseudos, ksampgs)
wflow = abilab.Work()
gs_t = wflow.register_scf_task(gs_inp)
gs_t.set_manager(gs_manager)
flow.register_work(wflow, workdir="gs_task")
ksamp = KSampling.automatic_density(structure,
kppa,
chksymbreak=0,
shifts=[1 / 4, 1 / 4, 1 / 4])
flow.register_work(raman_workflow(structure, pseudos, gs_t, ksamp),
workdir="bse_task")
return flow.allocate()
def raman_workflow(structure, pseudos, scf_t, ksamp):
# Generate 3 different input files for computing optical properties with BSE.
inp = abilab.MultiDataset(structure, pseudos=pseudos, ndtset=2)
inp.set_vars(**global_vars)
vars_ksamp = ksamp.to_abivars()
vars_ksamp.pop("#comment", None)
inp.set_vars(**vars_ksamp)
# NSCF run
inp[0].set_vars(
iscf=-2,
nband=10 * len(structure),
nbdbuf=2 * len(structure),
nstep=500,
tolwfr=1.e-22,
)
inp[1].set_vars(
gwmem=10,
gwpara=2,
optdriver=99,
nband=5 * len(structure), # 10 bands for 2 atoms
bs_loband=1 * len(structure), # start at 2 for 2 atoms
bs_algorithm=2, # Haydock
bs_calctype=1, # KS wavefunctions
bs_coulomb_term=21, # Use model dielectric function
mdf_epsinf=12.0,
bs_exchange_term=1, # Exchange term included
bs_freq_mesh="0 10 0.01 eV",
bs_hayd_term=0,
bs_coupling=0,
bs_haydock_tol="-0.01 0",
bs_haydock_niter=1000,
inclvkb=2,
ecuteps=4,
soenergy="0.8 eV",
ecutwfn=global_vars["ecut"],
)
nscf_inp, bse_inp = inp.split_datasets()
workflow = abilab.Work()
nscf_t = workflow.register(nscf_inp,
deps={scf_t: "DEN"},
task_class=abilab.NscfTask)
bse_t = workflow.register_bse_task(bse_inp, deps={nscf_t: "WFK"})
return workflow
def make_g0w0_scissors_flow(workdir="flow_lesson_g0w0", ngkpt=[2,2,2]):
# Change the value of ngkpt below to perform a GW calculation with a different k-mesh.
scf, bands_nscf, dos_nscf, gw_nscf, scr, sig = make_inputs(ngkpt=ngkpt)
flow = abilab.Flow(workdir=workdir)
work0 = abilab.BandStructureWork(scf, bands_nscf, dos_inputs=dos_nscf)
flow.register_work(work0)
work1 = abilab.Work()
gw_nscf_task = work1.register_nscf_task(gw_nscf, deps={work0[0]: "DEN"})
scr_task = work1.register_scr_task(scr, deps={gw_nscf_task: "WFK"})
sigma_task = work1.register_sigma_task(sig, deps={gw_nscf_task: "WFK", scr_task: "SCR"})
flow.register_work(work1)
return flow.allocate()
def build_flow(options):
# 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_")
# Get our templates
scf_inp, nscf_inp, scr_inp, sig_inp = make_inputs()
ecuteps_list = np.arange(2, 8, 2)
max_ecuteps = max(ecuteps_list)
flow = abilab.Flow(workdir=workdir,
manager=options.manager,
remove=options.remove)
# Band structure work to produce the WFK file
bands = abilab.BandStructureWork(scf_inp, nscf_inp)
flow.register_work(bands)
# Build a work made of two SCR runs with different value of nband
# Use max_ecuteps for the dielectric matrix (sigma tasks will
# read a submatrix when we test the convergence wrt to ecuteps.
scr_work = abilab.Work()
for inp in abilab.input_gen(scr_inp, nband=[10, 15]):
inp.set_vars(ecuteps=max_ecuteps)
scr_work.register_scr_task(inp, deps={bands.nscf_task: "WFK"})
flow.register_work(scr_work)
# Do a convergence study wrt ecuteps, each work is connected to a
# different SCR file computed with a different value of nband.
# Build a list of sigma inputs with different ecuteps
sigma_inputs = list(abilab.input_gen(sig_inp, ecuteps=ecuteps_list))
for scr_task in scr_work:
sigma_conv = abilab.SigmaConvWork(wfk_node=bands.nscf_task,
scr_node=scr_task,
sigma_inputs=sigma_inputs)
flow.register_work(sigma_conv)
return flow
def build_flow(options):
flow, eph_inp = make_flow_ephinp(options)
mpi_list = options.mpi_list
if mpi_list is None:
nkpt = len(eph_inp.abiget_ibz().points)
nks = nkpt * eph_inp["nsppol"]
mpi_list = [p for p in range(1, nks+1) if nks % p == 0]
print("Using mpi_list:", mpi_list)
else:
print("Using mpi_list from cmd line:", mpi_list)
eph_work = abilab.Work()
for mpi_procs, omp_threads in product(mpi_list, options.omp_list):
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(mpi_procs, omp_threads)
eph_work.register_eph_task(eph_inp, manager=manager, deps={flow[0][0]: "WFK", flow[1]: ["DDB", "DVDB"]})
flow.register_work(eph_work)
return flow.allocate()
def build_flow(options):
inp = make_input(paw=options.paw)
nkpt = len(inp.abiget_ibz().points)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
work = abilab.Work()
omp_list = options.omp_list
if omp_list is None: omp_list = [1, 2, 4, 6]
print("Using omp_list:", omp_list)
mpi_procs = 1
for omp_threads in omp_list:
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
work.register(inp, manager=manager)
flow.register_work(work)
return flow.allocate()
def build_flow(options):
template = make_input()
# Get the list of possible parallel configurations from abinit autoparal.
max_ncpus, min_eff = options.max_ncpus, options.min_eff
if max_ncpus is None:
nkpt = len(template.abiget_ibz().points)
max_ncpus = nkpt * template["nsppol"] * template["nband"] * 4
print("Getting all autoparal confs up to max_ncpus: ", max_ncpus,
" with efficiency >= ", min_eff)
pconfs = template.abiget_autoparal_pconfs(max_ncpus,
autoparal=1,
verbose=options.verbose)
if options.verbose: print(pconfs)
#parallelization
#paral_kgb 1
#npband 15
#npfft 3
#npkpt 4
#bandpp 2
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
work = abilab.Work()
for conf, omp_threads in product(pconfs, options.omp_list):
mpi_procs = conf.mpi_ncpus
if not options.accept_conf(conf, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
inp = template.new_with_vars(conf.vars)
work.register_scf_task(inp, manager=manager)
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def build_flow(options):
# 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_")
# Get the SCF and the NSCF input.
scf_input, nscf_input = make_scf_nscf_inputs()
# Build the flow.
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
# Create a Work, all tasks in work will read the file f
# Note that the file must exist when the work is created
# Use the standard approach based on tasks and works if
# there's a node who needs a file produced in the future.
work = abilab.Work()
denfile = abidata.ref_file("si_DEN-etsf.nc")
work.register(nscf_input, deps={denfile: "DEN"})
flow.register_work(work)
return flow
def build_flow(options):
gs_inp, nscf_inp = make_inputs(options)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
mpi_list = options.mpi_list
if mpi_list is None:
# Get the list of possible parallel configurations from abinit autoparal.
max_ncpus, min_eff = options.max_ncpus, options.min_eff
print("Getting all autoparal confs up to max_ncpus: ", max_ncpus,
" with efficiency >= ", min_eff)
pconfs = gs_inp.abiget_autoparal_pconfs(max_ncpus, autoparal=1)
else:
print("Initializing autoparal from command line options")
from pymatgen.io.abinit.tasks import ParalHints
pconfs = ParalHints.from_mpi_omp_lists(mpi_list, options.omp_list)
print(pconfs)
work = abilab.Work()
for conf, omp_threads in product(pconfs, options.omp_list):
mpi_procs = conf.mpi_ncpus
#if not options.accept_mpi_omp(mpi_procs,omp_threads): continue
if not options.accept_conf(conf, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
inp = gs_inp.new_with_vars(conf.vars)
scf_task = work.register_scf_task(inp, manager=manager)
inp2 = nscf_inp.new_with_vars(conf.vars)
work.register_nscf_task(inp2, manager=manager, deps={scf_task: "DEN"})
print("Found %d configurations" % len(work))
flow.register_work(work)
return flow.allocate()
def itest_flow_with_deadlocks(fwp):
"""
Test the behaviour of the scheduler in the presence of a deadlock
when we ignore errored tasks and we try to run all tasks in the flow.
The scheduler should detect the deadlock and exit when no other task can be executed.
"""
# Get the SCF and the NSCF input.
scf_input, nscf_input = make_scf_nscf_inputs()
# Build the flow.
flow = abilab.Flow(fwp.workdir, manager=fwp.manager)
work0 = abilab.BandStructureWork(scf_input, nscf_input, dos_inputs=nscf_input)
flow.register_work(work0)
scf_task, nscf_task, dos_task = work0[0], work0[1], work0[2]
work1 = abilab.Work()
work1.register_nscf_task(nscf_input, deps={scf_task: "DEN", dos_task: "WFK"})
# This task will deadlock when nscf_task reaches S_ERROR.
work1.register_nscf_task(nscf_input, deps={scf_task: "DEN", nscf_task: "WFK"})
flow.register_work(work1)
flow.allocate()
# Mock an Errored nscf_task. This will cause a deadlock in the flow.
nscf_task = mocks.change_task_start(nscf_task)
# Here we set max_num_abierrs to a very large number.
sched = flow.make_scheduler()
sched.max_num_abierrs = 10000
assert sched.start() == 0
flow.check_status(show=True)
assert not flow.all_ok
assert all(task.status == task.S_OK for task in [scf_task, dos_task, work1[0]])
assert all(task.status == task.S_ERROR for task in [nscf_task])
g = flow.find_deadlocks()
assert g.deadlocked and not g.runnables and not g.running
assert work1[1] in g.deadlocked
def build_flow(options):
inp = make_input()
mpi_list = options.mpi_list
if mpi_list is None:
nkpt = len(inp.abiget_ibz().points)
nks = nkpt * inp["nsppol"]
mpi_list = [p for p in range(1, nks + 1) if nks % p == 0]
print("Using mpi_list:", mpi_list)
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
for useylm in [0, 1]:
work = abilab.Work()
for mpi_procs, omp_threads in product(mpi_list, options.omp_list):
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
work.register_scf_task(inp.new_with_vars(useylm=useylm),
manager=manager)
flow.register_work(work)
return flow.allocate()
def build_flow(options):
flow = make_base_flow(options)
optic_input = abilab.OpticInput(
broadening=0.002,
domega=0.0003,
maxomega=0.3,
scissor=0.000,
tolerance=0.002,
num_lin_comp=1,
lin_comp=11,
num_nonlin_comp=2,
nonlin_comp=(123, 222),
)
mpi_list = options.mpi_list
if mpi_list is None:
mpi_list = [1, 2, 4, 8]
print("Using mpi_list:", mpi_list)
else:
print("Using mpi_list from cmd line:", mpi_list)
work = abilab.Work()
for mpi_procs, omp_threads in product(mpi_list, options.omp_list):
if not options.accept_mpi_omp(mpi_procs, omp_threads): continue
manager = options.manager.new_with_fixed_mpi_omp(
mpi_procs, omp_threads)
optic_task = abilab.OpticTask(optic_input,
manager=manager,
nscf_node=flow[0].nscf_task,
ddk_nodes=flow[1])
work.register_task(optic_task)
flow.register_work(work)
return flow.allocate()
def run_annaddb(flow, structure):
#structure = flow[0][0].
manager = abilab.TaskManager.from_user_config()
# We should have a DDB files with IFC(q) in work.outdir
ddb_files = []
for work in flow[1:]:
ddbs = work.outdir.list_filepaths(wildcard="*DDB")
assert len(ddbs) == 1
ddb_files.append(ddbs[0])
# TODO: Check automatic restart
assert all(work.finalized for work in flow)
assert flow.all_ok
# Merge the DDB files
out_ddb = flow.outdir.path_in("flow_DDB")
ddb_path = abilab.Mrgddb(manager=manager).merge(
flow.outdir.path,
ddb_files,
out_ddb=out_ddb,
description="DDB generated by %s" % __file__)
assert ddb_path == out_ddb
# Build new work with Anaddb tasks.
# Construct a manager with mpi_ncpus==1 since anaddb do not support mpi_ncpus > 1 (except in elphon)
shell_manager = manager.to_shell_manager()
awork = abilab.Work(manager=shell_manager)
# modes
anaddb_input = abilab.AnaddbInput.modes(structure)
atask = abilab.AnaddbTask(anaddb_input,
ddb_node=ddb_path,
manager=shell_manager)
awork.register(atask)
# Thermodynamics
anaddb_input = abilab.AnaddbInput.thermo(structure,
ngqpt=(40, 40, 40),
nqsmall=20)
atask = abilab.AnaddbTask(anaddb_input,
ddb_node=ddb_path,
manager=shell_manager)
awork.register(atask)
# Phonons bands and DOS with gaussian method
anaddb_input = abilab.AnaddbInput.phbands_and_dos(
structure,
ngqpt=(4, 4, 4),
nqsmall=10,
ndivsm=5,
dos_method="gaussian: 0.001 eV")
atask = abilab.AnaddbTask(anaddb_input,
ddb_node=ddb_path,
manager=shell_manager)
awork.register(atask)
# Phonons bands and DOS with tetrahedron method
anaddb_input = abilab.AnaddbInput.phbands_and_dos(structure,
ngqpt=(4, 4, 4),
nqsmall=10,
ndivsm=5,
dos_method="tetra")
atask = abilab.AnaddbTask(anaddb_input,
ddb_node=ddb_path,
manager=shell_manager)
awork.register(atask)
flow.register_work(awork)
flow.allocate()
flow.build()
for i, atask in enumerate(awork):
print("about to run anaddb task: %d" % i)
atask.start_and_wait()
#assert atask.status == atask.S_DONE
atask.check_status()
def build_flow(options, paral_kgb=0):
# 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_")
multi = abilab.MultiDataset(structure=data.structure_from_ucell("GaAs"),
pseudos=data.pseudos("31ga.pspnc",
"33as.pspnc"),
ndtset=5)
# Global variables
kmesh = dict(ngkpt=[4, 4, 4],
nshiftk=4,
shiftk=[[0.5, 0.5, 0.5], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0],
[0.0, 0.0, 0.5]])
global_vars = dict(ecut=2, paral_kgb=paral_kgb)
global_vars.update(kmesh)
multi.set_vars(global_vars)
# Dataset 1 (GS run)
multi[0].set_vars(
tolvrs=1e-6,
nband=4,
)
# NSCF run with large number of bands, and points in the the full BZ
multi[1].set_vars(
iscf=-2,
nband=20,
nstep=25,
kptopt=1,
tolwfr=1.e-9,
#kptopt=3,
)
# Fourth dataset : ddk response function along axis 1
# Fifth dataset : ddk response function along axis 2
# Sixth dataset : ddk response function along axis 3
for dir in range(3):
rfdir = 3 * [0]
rfdir[dir] = 1
multi[2 + dir].set_vars(
iscf=-3,
nband=20,
nstep=1,
nline=0,
prtwf=3,
kptopt=3,
nqpt=1,
qpt=[0.0, 0.0, 0.0],
rfdir=rfdir,
rfelfd=2,
tolwfr=1.e-9,
)
scf_inp, nscf_inp, ddk1, ddk2, ddk3 = multi.split_datasets()
# Initialize the flow.
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
bands_work = abilab.BandStructureWork(scf_inp, nscf_inp)
flow.register_work(bands_work)
ddk_work = abilab.Work()
for inp in [ddk1, ddk2, ddk3]:
ddk_work.register_ddk_task(inp, deps={bands_work.nscf_task: "WFK"})
flow.register_work(ddk_work)
# Optic does not support MPI with ncpus > 1.
optic_input = abilab.OpticInput(
broadening=0.002, # Value of the smearing factor, in Hartree
domega=0.0003, # Frequency mesh.
maxomega=0.3,
scissor=0.000, # Scissor shift if needed, in Hartree
tolerance=0.002, # Tolerance on closeness of singularities (in Hartree)
num_lin_comp=
1, # Number of components of linear optic tensor to be computed
lin_comp=11, # Linear coefficients to be computed (x=1, y=2, z=3)
num_nonlin_comp=
2, # Number of components of nonlinear optic tensor to be computed
nonlin_comp=(123, 222), # Non-linear coefficients to be computed
)
# TODO
# Check is the order of the 1WF files is relevant. Can we use DDK files ordered
# in an arbitrary way or do we have to pass (x,y,z)?
optic_task = abilab.OpticTask(optic_input,
nscf_node=bands_work.nscf_task,
ddk_nodes=ddk_work)
flow.register_task(optic_task)
return flow
def build_flow(options):
# 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_")
# Preparatory run for E-PH calculations.
# The sequence of datasets makes the ground states and
# all of the independent perturbations of the single Al atom
# for the irreducible qpoints in a 4x4x4 grid.
# Note that the q-point grid must be a sub-grid of the k-point grid (here 8x8x8)
pseudos = abidata.pseudos("Al.oncvpsp")
structure = abilab.Structure.from_abivars(
acell=3*[7.5],
rprim=[0.0, 0.5, 0.5,
0.5, 0.0, 0.5,
0.5, 0.5, 0.0],
typat=1,
xred=[0.0, 0.0, 0.0],
ntypat=1,
znucl=13,
)
gs_inp = abilab.AbinitInput(structure, pseudos)
gs_inp.set_vars(
prtpot=1,
istwfk="*1",
ecut=12.0,
nband=5,
occopt=7, # include metallic occupation function with a small smearing
tsmear=0.04,
tolvrs=1e-7,
timopt=-1,
)
# The kpoint grid is minimalistic to keep the calculation manageable.
gs_inp.set_kmesh(
ngkpt=[8, 8, 8],
kptopt=3,
shiftk=[0.0, 0.0, 0.0],
)
# Phonon calculation with 4x4x4
qpoints = np.reshape([
0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
2.50000000e-01, 0.00000000e+00, 0.00000000e+00,
5.00000000e-01, 0.00000000e+00, 0.00000000e+00,
2.50000000e-01, 2.50000000e-01, 0.00000000e+00,
5.00000000e-01, 2.50000000e-01, 0.00000000e+00,
-2.50000000e-01, 2.50000000e-01, 0.00000000e+00,
5.00000000e-01, 5.00000000e-01, 0.00000000e+00,
-2.50000000e-01, 5.00000000e-01, 2.50000000e-01,
], (-1,3))
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
work0 = flow.register_task(gs_inp, task_class=abilab.ScfTask)
ph_work = abilab.PhononWork.from_scf_task(work0[0], qpoints)
flow.register_work(ph_work)
# Build input file for E-PH run.
eph_inp = gs_inp.new_with_vars(
optdriver=7,
#ddb_ngqpt=[1, 1, 1], # q-mesh used to produce the DDB file (must be consisten with DDB data)
ddb_ngqpt=[4, 4, 4], # q-mesh used to produce the DDB file (must be consisten with DDB data)
eph_intmeth=2, # Tetra
eph_fsewin="0.8 eV", # Energy window around Ef
eph_mustar=0.12, # mustar parameter
# q-path for phonons and phonon linewidths.
ph_ndivsm=20,
ph_nqpath=3,
ph_qpath= [
0 , 0 , 0,
0.5, 0 , 0,
0.5, 0.5, 0,],
# phonon DOS obtained via Fourier interpolation
ph_intmeth=2, # Tetra for phonon DOS and A2F
ph_smear="0.001 eV",
ph_wstep="0.0001 eV",
ph_ngqpt=[16, 16, 16], # q-mesh for Fourier interpolatation of IFC and a2F(w)
ph_nqshift=1,
ph_qshift=[0, 0, 0],
)
eph_work = abilab.Work()
eph_task = eph_work.register_eph_task(eph_inp, deps={work0[0]: "WFK", ph_work: ["DDB", "DVDB"]})
flow.register_work(eph_work)
# EPH does not support autoparal
flow.allocate()
eph_task.with_fixed_mpi_omp(1, 1)
return flow
def itest_phonon_flow(fwp, tvars):
"""
Create an `Abinit` for phonon calculations:
1) One work for the GS run.
2) nqpt works for phonon calculations. Each work contains
nirred tasks where nirred is the number of irreducible phonon perturbations
for that particular q-point.
"""
if tvars.paral_kgb == 1:
pytest.xfail("Phonon flow with paral_kgb==1 is expected to fail (implementation problem)")
all_inps = scf_ph_inputs(tvars)
scf_input, ph_inputs = all_inps[0], all_inps[1:]
flow = abilab.phonon_flow(fwp.workdir, scf_input, ph_inputs, manager=fwp.manager)
flow.build_and_pickle_dump()
t0 = flow[0][0]
t0.start_and_wait()
assert t0.uses_paral_kgb(tvars.paral_kgb)
flow.check_status()
assert t0.status == t0.S_OK
flow.show_status()
for work in flow[1:]:
for task in work:
task.start_and_wait()
assert task.status == t0.S_DONE
flow.check_status(show=True)
# We should have a DDB files with IFC(q) in work.outdir
ddb_files = []
for work in flow[1:]:
ddbs = work.outdir.list_filepaths(wildcard="*DDB")
assert len(ddbs) == 1
ddb_files.append(ddbs[0])
assert all(work.finalized for work in flow)
assert flow.all_ok
# Merge the DDB files
out_ddb = flow.outdir.path_in("flow_DDB")
ddb_path = abilab.Mrgddb().merge(flow.outdir.path, ddb_files, out_ddb=out_ddb,
description="DDB generated by %s" % __file__)
assert ddb_path == out_ddb
# Test PhononTask inspect method
ph_task = flow[1][0]
# paral_kgb does not make sense for DFPT!
assert not ph_task.uses_paral_kgb(tvars.paral_kgb)
if has_matplotlib():
ph_task.inspect(show=False)
# Test get_results
ph_task.get_results()
# Build new work with Anaddb tasks.
# Construct a manager with mpi_procs==1 since anaddb do not support mpi_procs > 1 (except in elphon)
shell_manager = fwp.manager.to_shell_manager(mpi_procs=1)
awork = abilab.Work(manager=shell_manager)
# Phonons bands and DOS with gaussian method
anaddb_input = abilab.AnaddbInput.phbands_and_dos(
scf_input.structure, ngqpt=(4, 4, 4), ndivsm=5, nqsmall=10, dos_method="gaussian: 0.001 eV")
atask = abilab.AnaddbTask(anaddb_input, ddb_node=ddb_path, manager=shell_manager)
awork.register(atask)
# Phonons bands and DOS with tetrahedron method
anaddb_input = abilab.AnaddbInput.phbands_and_dos(
scf_input.structure, ngqpt=(4, 4, 4), ndivsm=5, nqsmall=10, dos_method="tetra")
atask = abilab.AnaddbTask(anaddb_input, ddb_node=ddb_path, manager=shell_manager)
awork.register(atask)
flow.register_work(awork)
flow.allocate()
flow.build()
for i, atask in enumerate(awork):
atask.history.info("about to run anaddb task: %d", i)
atask.start_and_wait()
assert atask.status == atask.S_DONE
atask.check_status()
assert atask.status == atask.S_OK
def itest_optic_flow(fwp, tvars):
"""Test optic calculations."""
if tvars.paral_kgb == 1:
pytest.xfail(
"Optic flow with paral_kgb==1 is expected to fail (implementation problem)"
)
"""
0.002 ! Value of the smearing factor, in Hartree
0.0003 0.3 ! Difference between frequency values (in Hartree), and maximum frequency ( 1 Ha is about 27.211 eV)
0.000 ! Scissor shift if needed, in Hartree
0.002 ! Tolerance on closeness of singularities (in Hartree)
1 ! Number of components of linear optic tensor to be computed
11 ! Linear coefficients to be computed (x=1, y=2, z=3)
2 ! Number of components of nonlinear optic tensor to be computed
123 222 ! Non-linear coefficients to be computed
"""
optic_input = abilab.OpticInput(
broadening=0.002,
domega=0.0003,
maxomega=0.3,
scissor=0.000,
tolerance=0.002,
num_lin_comp=1,
lin_comp=11,
num_nonlin_comp=2,
nonlin_comp=(123, 222),
)
print(optic_input)
#raise ValueError()
scf_inp, nscf_inp, ddk1, ddk2, ddk3 = make_inputs(tvars)
flow = abilab.Flow(fwp.workdir, manager=fwp.manager)
bands_work = abilab.BandStructureWork(scf_inp, nscf_inp)
flow.register_work(bands_work)
# work with DDK tasks.
ddk_work = abilab.Work()
for inp in [ddk1, ddk2, ddk3]:
ddk_work.register_ddk_task(inp, deps={bands_work.nscf_task: "WFK"})
flow.register_work(ddk_work)
flow.allocate()
flow.build_and_pickle_dump(abivalidate=True)
# Run the tasks
for task in flow.iflat_tasks():
task.start_and_wait()
assert task.status == task.S_DONE
flow.check_status()
assert flow.all_ok
# Optic does not support MPI with ncores > 1 hence we have to construct a manager with mpi_procs==1
shell_manager = fwp.manager.to_shell_manager(mpi_procs=1)
# Build optic task and register it
optic_task1 = abilab.OpticTask(optic_input,
nscf_node=bands_work.nscf_task,
ddk_nodes=ddk_work,
manager=shell_manager)
flow.register_task(optic_task1)
flow.allocate()
flow.build_and_pickle_dump(abivalidate=True)
optic_task1.start_and_wait()
assert optic_task1.status == optic_task1.S_DONE
# Now we do a similar calculation but the dependencies are represented by
# strings with the path to the input files instead of task objects.
ddk_nodes = [task.outdir.has_abiext("1WF") for task in ddk_work]
#ddk_nodes = [task.outdir.has_abiext("DDK") for task in ddk_work]
print("ddk_nodes:", ddk_nodes)
assert all(ddk_nodes)
#nscf_node = bands_work.nscf_task
nscf_node = bands_work.nscf_task.outdir.has_abiext("WFK")
assert nscf_node
# This does not work yet
optic_task2 = abilab.OpticTask(optic_input,
nscf_node=nscf_node,
ddk_nodes=ddk_nodes)
flow.register_task(optic_task2)
flow.allocate()
flow.build_and_pickle_dump(abivalidate=True)
assert len(flow) == 4
optic_task2.start_and_wait()
assert optic_task2.status == optic_task2.S_DONE
flow.check_status()
flow.show_status()
assert flow.all_ok
assert all(work.finalized for work in flow)
#assert flow.validate_json_schema()
# Test get_results
optic_task2.get_results()
def make_base_flow(options):
multi = abilab.MultiDataset(structure=data.structure_from_ucell("GaAs"),
pseudos=data.pseudos("31ga.pspnc",
"33as.pspnc"),
ndtset=5)
# Global variables
kmesh = dict(ngkpt=[4, 4, 4],
nshiftk=4,
shiftk=[[0.5, 0.5, 0.5], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0],
[0.0, 0.0, 0.5]])
paral_kgb = 1
global_vars = dict(ecut=2, paral_kgb=paral_kgb)
global_vars.update(kmesh)
multi.set_vars(global_vars)
# Dataset 1 (GS run)
multi[0].set_vars(
tolvrs=1e-6,
nband=4,
)
# NSCF run with large number of bands, and points in the the full BZ
multi[1].set_vars(
iscf=-2,
nband=20,
nstep=25,
kptopt=1,
tolwfr=1.e-9,
#kptopt=3,
)
# Fourth dataset: ddk response function along axis 1
# Fifth dataset: ddk response function along axis 2
# Sixth dataset: ddk response function along axis 3
for dir in range(3):
rfdir = 3 * [0]
rfdir[dir] = 1
multi[2 + dir].set_vars(
iscf=-3,
nband=20,
nstep=1,
nline=0,
prtwf=3,
kptopt=3,
nqpt=1,
qpt=[0.0, 0.0, 0.0],
rfdir=rfdir,
rfelfd=2,
tolwfr=1.e-9,
)
scf_inp, nscf_inp, ddk1, ddk2, ddk3 = multi.split_datasets()
# Initialize the flow.
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.manager)
bands_work = abilab.BandStructureWork(scf_inp, nscf_inp)
flow.register_work(bands_work)
flow.exclude_from_benchmark(bands_work)
ddk_work = abilab.Work()
for inp in [ddk1, ddk2, ddk3]:
ddk_work.register_ddk_task(inp, deps={bands_work.nscf_task: "WFK"})
flow.register_work(ddk_work)
flow.exclude_from_benchmark(ddk_work)
return flow
def raman_work(structure, pseudos, ngkpt, shiftk, ddk_manager, shell_manager):
# Generate 3 different input files for computing optical properties with BSE.
multi = abilab.MultiDataset(structure, pseudos=pseudos, ndtset=5)
multi.set_vars(global_vars)
multi.set_kmesh(ngkpt=ngkpt, shiftk=shiftk)
# GS run
multi[0].set_vars(
tolvrs=1e+8,
nband=59,
)
# NSCF run
multi[1].set_vars(
iscf=-2,
nband=100,
kptopt=1,
tolwfr=1.e+12,
)
# DDK along 3 directions
# Third dataset : ddk response function along axis 1
# Fourth dataset : ddk response function along axis 2
# Fifth dataset : ddk response function along axis 3
for dir in range(3):
rfdir = 3 * [0]
rfdir[dir] = 1
multi[2 + dir].set_vars(
iscf=-3,
nband=100,
nstep=1,
nline=0,
prtwf=3,
kptopt=1,
nqpt=1,
qpt=[0.0, 0.0, 0.0],
rfdir=rfdir,
rfelfd=2,
tolwfr=1.e+12,
)
scf_inp, nscf_inp, ddk1, ddk2, ddk3 = multi.split_datasets()
ddk_inputs = [ddk1, ddk2, ddk3]
work = abilab.Work()
scf_t = work.register_scf_task(scf_inp)
nscf_t = work.register_nscf_task(nscf_inp, deps={scf_t: "DEN"})
ddk_nodes = []
for inp in ddk_inputs:
ddk_t = work.register_ddk_task(inp, deps={nscf_t: "WFK"})
ddk_t.set_manager(ddk_manager)
ddk_nodes.append(ddk_t)
optic_t = abilab.OpticTask(optic_input,
nscf_node=nscf_t,
ddk_nodes=ddk_nodes,
manager=shell_manager)
work.register(optic_t)
return work
