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()