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_")
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
# Create the work for the band structure calculation.
structure = abidata.structure_from_ucell("NiO")
pseudos = abidata.pseudos("28ni.paw", "8o.2.paw")
# The code below set up the parameters for the LDA+U calculation in NiO.
#usepawu 1
#lpawu 2 -1
#upawu 8.0 0.0 eV
#jpawu 0.8 0.0 eV
usepawu = 1
u_values = [5.0, 8.0]
for u in u_values:
# Apply U-J on Ni only.
luj_params = abilab.LdauParams(usepawu, structure)
luj_params.luj_for_symbol("Ni", l=2, u=u, j=0.1*u, unit="eV")
scf_input, nscf_input, dos_input = make_scf_nscf_dos_inputs(structure, pseudos, luj_params)
work = abilab.BandStructureWork(scf_input, nscf_input, dos_inputs=dos_input)
flow.register_work(work)
return flow
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 itest_flow_without_runnable_tasks(fwp):
"""
Test the behaviour of the scheduler when we ignore errrors and
all the task that can be executed have been submitted.
The scheduler should detect this condition and exit.
"""
# 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)
flow.register_work(work0)
scf_task, nscf_task = work0.scf_task, work0.nscf_task
flow.allocate()
# Mock an Errored nscf_task. This will cause a deadlock in the flow.
nscf_task = mocks.change_task_start(nscf_task)
sched = flow.make_scheduler()
sched.max_num_abierrs = 10000
assert sched.start() == 0
flow.check_status(show=True)
assert not flow.all_ok
assert scf_task.status == scf_task.S_OK
assert nscf_task.status == nscf_task.S_ERROR
g = flow.find_deadlocks()
assert not g.deadlocked and not g.runnables and not g.running
def make_workflow(structure, pseudos, paral_kgb=1):
"""
Return a `Workflow` object defining a band structure calculation
for given `Structure`.
"""
# Variables global to the SCF and the NSCF run.
global_vars = dict(
ecut=FloatWithUnit(100, "eV").to("Ha"),
paral_kgb=paral_kgb,
#nband=8,
)
# GS + NSCF run
multi = abilab.MultiDataset(structure, pseudos=pseudos, ndtset=2)
multi.set_vars(global_vars)
# (GS run)
multi[0].set_kmesh(ngkpt=[8,8,8], shiftk=[0,0,0])
multi[0].set_vars(tolvrs=1e-6)
# (NSCF run)
multi[1].set_vars(
iscf=-2,
tolwfr=1e-12,
kptopt=0,
nkpt=1,
kpt=[0, 0, 0],
)
gs_inp, nscf_inp = multi.split_datasets()
return abilab.BandStructureWork(gs_inp, nscf_inp)
def build_flow(options):
gs_inp, nscf_inp, ddk_inp = make_inputs()
flow = BenchmarkFlow(workdir=options.get_workdir(__file__),
remove=options.remove)
ebands_work = abilab.BandStructureWork(gs_inp, nscf_inp)
flow.register_work(ebands_work)
flow.exclude_from_benchmark(ebands_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 = ddk_inp.abiget_autoparal_pconfs(max_ncpus, autoparal=1)
print(pconfs)
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 = ddk_inp.new_with_vars(conf.vars)
work.register_ddk_task(inp,
manager=manager,
deps={ebands_work[1]: "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_")
# build the structures
base_structure = abilab.Structure.from_file(data.cif_file("si.cif"))
modifier = abilab.StructureModifier(base_structure)
etas = [-0.1, 0, +0.1]
ph_displ = np.reshape(np.zeros(3 * len(base_structure)), (-1, 3))
ph_displ[0, :] = [+1, 0, 0]
ph_displ[1, :] = [-1, 0, 0]
displaced_structures = modifier.displace(ph_displ, etas, frac_coords=False)
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
for structure in displaced_structures:
# Create the work for the band structure calculation.
scf_input, nscf_input = make_scf_nscf_inputs(structure)
work = abilab.BandStructureWork(scf_input, nscf_input)
flow.register_work(work)
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_")
# Initialize structure and pseudos.
structure = abilab.Structure.from_file(abidata.cif_file("si.cif"))
pseudos = abidata.pseudos("14si.pspnc")
# Initialize the flow.
flow = abilab.Flow(workdir=workdir,
manager=options.manager,
remove=options.remove)
# Use ebands_input factory function to build inputs.
multi = abilab.ebands_input(structure,
pseudos,
kppa=40,
nscf_nband=6,
ndivsm=10,
ecut=6)
work = abilab.BandStructureWork(scf_input=multi[0], nscf_input=multi[1])
flow.register_work(work)
return flow
def test_ebands_input(self):
"""Testing ebands_input factory."""
multi = ebands_input(self.si_structure,
self.si_pseudo,
kppa=10,
ecut=2)
scf_inp, nscf_inp = multi.split_datasets()
flow = abilab.Flow.temporary_flow()
flow.register_work(abilab.BandStructureWork(scf_inp, nscf_inp))
assert flow.build_and_pickle_dump(abivalidate=True) == 0
def test_ebands_input(self):
"""Testing ebands_input factory."""
inp = ebands_input(self.si_structure, self.si_pseudo, kppa=10, ecut=2)
self.validate_inp(inp)
scf_inp, nscf_inp = inp.split_datasets()
#inp = ebands_input(self.si_structure, self.si_pseudo, scf_kppa, nscf_nband, dos_kppa=dos_kppa)
#print(inp)
#self.validate_inp(inp)
#return
flow = abilab.Flow("flow_ebands_input")
flow.register_work(abilab.BandStructureWork(scf_inp, nscf_inp))
flow.allocate()
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_")
# Create the Flow.
flow = abilab.Flow(workdir, manager=options.manager, remove=options.remove)
# Create the task defining the calculation and run and register it in the flow
for nsppol in [1,2]:
scf_input, nscf_input = make_scf_nscf_inputs(nsppol)
work = abilab.BandStructureWork(scf_input, nscf_input)
flow.register_work(work)
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_")
# 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):
# 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)
paral_kgb = 1
#paral_kgb = 0 # This one is OK
# Create a relaxation work and add it to the flow.
ion_inp, ioncell_inp = make_ion_ioncell_inputs(paral_kgb=paral_kgb)
relax_work = abilab.RelaxWork(ion_inp, ioncell_inp)
flow.register_work(relax_work)
scf_inp, nscf_inp = make_scf_nscf_inputs(paral_kgb=paral_kgb)
bands_work = abilab.BandStructureWork(scf_inp, nscf_inp)
# The scf task in bands work restarts from the DEN file of the last task in relax_work
if paral_kgb == 0:
# cg works fine if we restart from the WFK
bands_work.scf_task.add_deps({relax_work[-1]: "WFK"})
else:
# --> This triggers an infamous bug in abinit
bands_work.scf_task.add_deps({relax_work[-1]: "WFK"})
# --> This is ok if we used fourier_interp to change the FFT mesh.
#bands_work.scf_task.add_deps({relax_work[-1]: "DEN"})
# All task in bands_work will fetch the relaxed structure from the last task in relax_work
for task in bands_work:
task.add_deps({relax_work[-1]: "@structure"})
flow.register_work(bands_work)
flow.allocate()
flow.use_smartio()
flow.set_garbage_collector()
return flow
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 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 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 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 itest_htc_bandstructure(fwp, tvars):
"""Test band-structure calculations done with the HTC interface."""
structure = abilab.Structure.from_file(abidata.cif_file("si.cif"))
pseudos = abidata.pseudos("14si.pspnc")
# TODO: Add this options because I don't like the kppa approach
# I had to use it because it was the approach used in VaspIO
#dos_ngkpt = [4,4,4]
#dos_shiftk = [0.1, 0.2, 0.3]
# Initialize the flow.
flow = abilab.Flow(workdir=fwp.workdir, manager=fwp.manager)
# Use ebands_input factory function to build inputs.
multi = abilab.ebands_input(structure,
pseudos,
kppa=20,
nscf_nband=6,
ndivsm=5,
ecut=2,
dos_kppa=40,
spin_mode="unpolarized")
work = abilab.BandStructureWork(scf_input=multi[0],
nscf_input=multi[1],
dos_inputs=multi[2:])
multi.set_vars(paral_kgb=tvars.paral_kgb)
flow.register_work(work)
flow.allocate()
flow.build_and_pickle_dump(abivalidate=True)
fwp.scheduler.add_flow(flow)
assert fwp.scheduler.start() == 0
assert not fwp.scheduler.exceptions
assert fwp.scheduler.nlaunch == 3
flow.show_status()
assert flow.all_ok
assert all(work.finalized for work in flow)
# Test if GSR files are produced and are readable.
for i, task in enumerate(work):
with task.open_gsr() as gsr:
print(gsr)
assert gsr.nsppol == 1
#assert gsr.structure == structure
ebands = gsr.ebands
# TODO: This does not work yet because GSR files do not contain
# enough info to understand if we have a path or a mesh.
#if i == 2:
# Bandstructure case
#assert ebands.has_bzpath
#with pytest.raises(ebands.Error):
# ebands.get_edos()
if i == 3:
# DOS case
assert ebands.has_bzmesh
gsr.bands.get_edos()
