def build_flow(options): """ Create a `Flow` for phonon calculations. The flow has two works. """ # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_phonons_wkq.py") options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") flow = flowtk.Flow(workdir=options.workdir) # Build input for GS calculation and create first work with 1 ScfTask. scf_input = make_scf_input() work = flow.register_scf_task(scf_input) scf_task = work[0] # Create work for phonon calculation with WFQ files with a [4, 4, 4] q-mesh. # Electric field and Born effective charges are also computed. wfkq_work = flowtk.PhononWfkqWork.from_scf_task(scf_task, ngqpt=[4, 4, 4], with_becs=True) flow.register_work(wfkq_work) return flow
def itest_dilatmxerror_handler(fwp): """Test the handler of DilatmxError. The test triggers: --- !DilatmxError message: | Dilatmx has been exceeded too many times (4) Restart your calculation from larger lattice vectors and/or a larger dilatmx src_file: mover.F90 src_line: 840 ... in variable cell structural optimizations. """ #if fwp.on_travis: pytest.xfail( "dilatmxerror_handler is not portable and it's been disabled!") structure = abilab.Structure.from_file(abidata.cif_file("si.cif")) structure.scale_lattice(structure.volume * 0.8) # Perturb the structure (random perturbation of 0.1 Angstrom) #structure.perturb(distance=0.1) inp = abilab.AbinitInput(structure=structure, pseudos=abidata.pseudos("14si.pspnc")) inp.set_vars( ecut=4, ngkpt=[4, 4, 4], shiftk=[0, 0, 0], nshiftk=1, chksymbreak=0, paral_kgb=1, optcell=1, ionmov=2, ecutsm=0.5, dilatmx=1.01, tolrff=0.02, tolmxf=5.0e-5, strfact=100, ntime=50, #ntime=5, To test the restart ) # Create the flow flow = flowtk.Flow(fwp.workdir, manager=fwp.manager) flow.register_task(inp, task_class=flowtk.RelaxTask) flow.allocate() assert flow.make_scheduler().start() == 0 flow.show_status() if not flow.all_ok: flow.debug() raise RuntimeError() task = flow[0][0] # Don't check the number of corrections as it's not portable. assert len(task.corrections) for i in range(task.num_corrections): assert task.corrections[i]["event"]["@class"] == "DilatmxError"
def build_flow(options): """ Create a `Flow` for phonon calculations. The flow has two works. The first work contains a single GS task that produces the WFK file used in DFPT Then we have multiple Works that are generated automatically in order to compute the dynamical matrix on a [4, 4, 4] mesh. Symmetries are taken into account: only q-points in the IBZ are generated and for each q-point only the independent atomic perturbations are computed. """ # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_becs_and_epsilon_vs_kpts.py") options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") flow = flowtk.Flow(workdir=options.workdir) for ngkpt in [(2, 2, 2), (4, 4, 4), (8, 8, 8)]: # Build input for GS calculation scf_input = make_scf_input(ngkpt=ngkpt) flow.register_scf_task(scf_input, append=True) for scf_task in flow[0]: bec_work = flowtk.BecWork.from_scf_task(scf_task) flow.register_work(bec_work) return flow
def build_flow(options=None): """ Create a `Flow` for phonon calculations. The flow has one work with: - 1 GS Task - 3 DDK Task - 4 Phonon Tasks (Gamma point) - 6 Elastic tasks (3 uniaxial + 3 shear strain) The Phonon tasks and the elastic task will read the 3 DDK files produced at the beginning """ workdir = options.workdir if (options and options.workdir) else "flow_elastic" flow = flowtk.Flow(workdir=workdir) # Build input for GS calculation and register the first work. scf_input = make_scf_input() # Build work for elastic properties (clamped-ions) # activate internal strain and piezoelectric part. elast_work = flowtk.ElasticWork.from_scf_input(scf_input, with_relaxed_ion=True, with_piezo=True) flow.register_work(elast_work) return flow
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 = flowtk.Flow(fwp.workdir, manager=fwp.manager) work0 = flowtk.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 build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_ht_si_ebands.py") options.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 = flowtk.Flow(workdir=options.workdir, manager=options.manager) # Use the ebands_input factory function to build a MultiDataset. # keyword args are optional (default values are given or computed automatically, see docs). multi = abilab.ebands_input(structure, pseudos, kppa=40, dos_kppa=80, nscf_nband=6, ndivsm=10, ecut=6, spin_mode="unpolarized") work = flowtk.BandStructureWork(scf_input=multi[0], nscf_input=multi[1], dos_inputs=multi[2]) flow.register_work(work) return flow
def itest_atomic_relaxation(fwp, tvars): """Test atomic relaxation with automatic restart.""" # Build the flow flow = flowtk.Flow(fwp.workdir, manager=fwp.manager) ion_input = ion_relaxation(tvars, ntime=2) ion_input["chksymtnons"] = 0 work = flow.register_task(ion_input, task_class=flowtk.RelaxTask) flow.allocate() flow.build_and_pickle_dump(abivalidate=True) # Run t0, and check status t0 = work[0] t0.start_and_wait() assert t0.returncode == 0 t0.check_status() assert t0.status == t0.S_UNCONVERGED assert t0.initial_structure == ion_input.structure unconverged_structure = t0.get_final_structure() assert unconverged_structure != t0.initial_structure # Use the default value ntime=50 and we can converge the calculation. t0.input.set_vars(ntime=50) t0.build() assert t0.restart() t0.wait() assert t0.num_restarts == 1 # At this point, we should have reached S_OK. assert t0.status == t0.S_DONE t0.check_status() assert t0.status == t0.S_OK final_structure = t0.get_final_structure() assert final_structure != unconverged_structure flow.show_status() assert all(work.finalized for work in flow) if not flow.all_ok: flow.debug() raise RuntimeError() # post-processing tools if has_matplotlib(): assert t0.inspect(show=False) is not None with t0.open_hist() as hist: hist.to_string(verbose=2) # from_file accepts HIST files as well. assert np.all(hist.structures[-1].frac_coords == abilab.Structure.from_file(hist.filepath).frac_coords) with t0.open_gsr() as gsr: gsr.to_string(verbose=2) gsr.pressure == 1.8280 t0.get_results()
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 = flowtk.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 = flowtk.BandStructureWork(scf_input=multi[0], nscf_input=multi[1]) 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_") pseudos = abidata.pseudos("14si.pspnc", "8o.pspnc") base_structure = abilab.Structure.from_file(abidata.cif_file("si.cif")) news, uparams = [], [0.2, 0.3] for u in uparams: new = special_positions(base_structure.lattice, u) news.append(new) flow = flowtk.Flow(workdir, manager=options.manager, remove=options.remove) # Create the list of workflows. Each workflow defines a band structure calculation. for new_structure, u in zip(news, uparams): # Generate the workflow and register it. flow.register_work(make_workflow(new_structure, pseudos)) return flow
def test_scf(): atoms = build_structure(name='BaTiO3', mag='PM') scf_inp = make_scf_input(atoms, spin_mode='unpolarized',is_metal=False) ebands_inp = ebands_from_gsinput(scf_inp) dos_inp = dos_from_gsinput(scf_inp, dos_kppa=400) #scf_task = flowapi.ScfTask(scf_inp) #ebands_task = flowapi.NscfTask(ebands_inp) #dos_task = flowapi.NscfTask(dos_inp) band_work = flowapi.BandStructureWork( scf_inp, ebands_inp, dos_inp, workdir=None) #phonon_work=flowapi.PhononWork() #phonon_work.from_scf_input() flow = flowapi.Flow('BaTiO3_scf') flow.register_work(band_work) #flow.build_and_pickle_dump() #flow.plot_networkx() #flow.show_status() #flow.make_scheduler().start() flow_phbands = flowapi.PhononFlow.from_scf_input( 'BaTiO3_phonon', scf_inp, ph_ngqpt=(2, 2, 2), with_becs=True) flow_phbands.make_scheduler().start() flow_phbands.show_summary()
def build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_phfrozen_ebands.py") options.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 = flowtk.Flow(options.workdir, manager=options.manager) for structure in displaced_structures: # Create the work for the band structure calculation. scf_input, nscf_input = make_scf_nscf_inputs(structure) work = flowtk.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_") if not options.workdir: options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") flow = flowtk.Flow(workdir=options.workdir, manager=options.manager) for nspinor in (1, 2): #for nspinor in (2,): # Get our templates scf_inp, bands_inp, nscf_inp, scr_inp, sig_inp = make_inputs(nspinor) # Band structure work to produce the WFK file bands_work = flowtk.BandStructureWork(scf_inp, bands_inp, dos_inputs=[nscf_inp]) flow.register_work(bands_work) # Build a work made of two SCR runs with different value of nband gw_work = flowtk.Work() scr_task = gw_work.register_scr_task(scr_inp, deps={bands_work[2]: "WFK"}) gw_work.register_sigma_task(sig_inp, deps={ bands_work[2]: "WFK", scr_task: "SCR" }) flow.register_work(gw_work) return flow
def build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace(".py", "").replace("run_","flow_") flow = flowtk.Flow(options.workdir, manager=options.manager) pseudos = abidata.pseudos("14si.pspnc") # Get the unperturbed structure. base_structure = abidata.structure_from_ucell("Si") etas = [-.001, 0, +.001] ph_displ = np.reshape(np.zeros(3*len(base_structure)), (-1,3)) ph_displ[0,:] = [+1, 0, 0] ph_displ[1,:] = [-1, 0, 0] # Build new structures by displacing atoms according to the phonon displacement # ph_displ (in cartesian coordinates). The Displacement is normalized so that # the maximum atomic diplacement is 1 Angstrom and then multiplied by eta. modifier = abilab.StructureModifier(base_structure) displaced_structures = modifier.displace(ph_displ, etas, frac_coords=False) # Generate the different shifts to average ndiv = 2 shift1D = np.arange(1,2*ndiv+1,2)/(2*ndiv) all_shifts = [[x,y,z] for x in shift1D for y in shift1D for z in shift1D] all_shifts = [[0, 0, 0]] for structure, eta in zip(displaced_structures, etas): for shift in all_shifts: flow.register_work(raman_work(structure, pseudos, shift)) return flow
def build_flow(options): # Set working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace( ".py", "").replace("run_", "flow_") # Get the SCF input (here NC with SOC) scf_input = make_scf_input(nspinor=2, usepaw=0) # Build the flow with different steps. from abipy.flowtk.effmass_works import EffMassLineWork flow = flowtk.Flow(workdir=options.workdir, manager=options.manager) # Multiple calculations with different step for finite difference. for i, step in enumerate((0.01, 0.005)): if i == 0: den_node = None work = EffMassLineWork.from_scf_input(scf_input, k0_list=(0, 0, 0), step=step, npts=10, red_dirs=[[1, 0, 0], [1, 1, 0]], cart_dirs=[[1, 0, 0], [1, 1, 1], [1, 1, 0]], den_node=den_node) # Will start from the DEN file produced in the first iteration. if i == 0: den_node = work[0] flow.register_work(work) return flow
def itest_relaxation_with_target_dilatmx(fwp, tvars): """Test structural relaxations with automatic restart from DEN files.""" # Build the flow flow = flowtk.Flow(fwp.workdir, manager=fwp.manager) # Use small value for ntime to trigger restart, then disable the output of the WFK file. ion_input, ioncell_input = make_ion_ioncell_inputs(tvars, dilatmx=1.05) target_dilatmx = 1.03 relax_work = flowtk.RelaxWork(ion_input, ioncell_input, target_dilatmx=target_dilatmx) flow.register_work(relax_work) assert flow.make_scheduler().start() == 0 flow.show_status() assert all(work.finalized for work in flow) if not flow.all_ok: flow.debug() raise RuntimeError() #assert relax_work.last_dilatmx <= target_dilatmx # we should have (0, 1) restarts for i, task in enumerate(relax_work): assert task.status == task.S_OK assert task.num_restarts == i assert task.num_corrections == 0 assert relax_work[1].input["dilatmx"] == 1.03 # check that when decreasing the dilatmx it actually takes the previously relaxed # structure and does not start from scratch again: the lattice should not be the same. assert not np.allclose(relax_work.ion_task.get_final_structure().lattice_vectors(), relax_work.ioncell_task.input.structure.lattice_vectors()) flow.rmtree()
def build_flow(options): # Set working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace(".py", "").replace("run_", "flow_") # Build GS input file. pseudos = abidata.pseudos("Si.GGA_PBE-JTH-paw.xml") #silicon = abilab.Structure.zincblende(5.431, ["Si", "Si"], units="ang") silicon = abidata.cif_file("si.cif") scf_input = abilab.AbinitInput(silicon, pseudos) ecut = 12 scf_input.set_vars( ecut=ecut, pawecutdg=40, nband=6, paral_kgb=0, iomode=3, toldfe=1e-9, ) # K-point sampling (shifted) scf_input.set_autokmesh(nksmall=4) from abipy.flowtk.gs_works import EosWork flow = flowtk.Flow(options.workdir, manager=options.manager) # Si is cubic and atomic positions are fixed by symmetry so we # use move_atoms=False to compute E(V) with SCF-GS tasks instead of # performing a constant-volume optimization of the cell geometry. work = EosWork.from_scf_input(scf_input, move_atoms=False, ecutsm=0.5) flow.register_work(work) flow.allocate(use_smartio=True) return flow
def build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") flow = flowtk.Flow(options.workdir, manager=options.manager) # 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 = 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 = flowtk.BandStructureWork(scf_input, nscf_input, dos_inputs=dos_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_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_relax.py") options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") # Create the flow flow = flowtk.Flow(options.workdir, manager=options.manager) # Create a relaxation work and add it to the flow. ion_inp, ioncell_inp = make_ion_ioncell_inputs() relax_work = flowtk.RelaxWork(ion_inp, ioncell_inp) flow.register_work(relax_work) #bands_work = flowtk.BandStructureWork(scf_input, nscf_input) bands_work = flowtk.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): # Set working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace( ".py", "").replace("run_", "flow_") # Get the SCF input (without SOC) scf_input = make_scf_input(nspinor=1, usepaw=1) # Build the flow. from abipy.flowtk.effmass_works import EffMassDFPTWork, EffMassAutoDFPTWork flow = flowtk.Flow(workdir=options.workdir, manager=options.manager) # Compute effective masses for each k in k0_list. # effmass_bands_f90 defines the band range for each k in k0_list # Here we are interested in the effective masses at the Gamma point for the valence bands effmass_bands_f90 = [1, 4] if scf_input["nspinor"] == 1 else [1, 8] work = EffMassDFPTWork.from_scf_input(scf_input, k0_list=(0, 0, 0), effmass_bands_f90=effmass_bands_f90) flow.register_work(work) # or use this Work to detect band edges automatically but increase ndivsm and decrease tolwfr! work = EffMassAutoDFPTWork.from_scf_input(scf_input, ndivsm=5, tolwfr=1e-12) flow.register_work(work) return flow
def build_flow(options): # Init structure and pseudos. structure = abilab.Structure.from_file(abidata.cif_file("si.cif")) pseudos = abidata.pseudos("14si.pspnc") # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(__file__).replace(".py", "").replace("run_", "flow_") # Initialize the flow. flow = flowtk.Flow(options.workdir, manager=options.manager) scf_kppa = 120 nscf_nband = 40 ecut, ecuteps, ecutsigx = 6, 2, 4 #scr_nband = 50 #sigma_nband = 50 multi = abilab.g0w0_with_ppmodel_inputs( structure, pseudos, scf_kppa, nscf_nband, ecuteps, ecutsigx, ecut=ecut, shifts=(0, 0, 0), # By default the k-mesh is shifted! TODO: Change default? accuracy="normal", spin_mode="unpolarized", smearing=None, #ppmodel="godby", charge=0.0, scf_algorithm=None, inclvkb=2, scr_nband=None, #sigma_nband=None, gw_qprange=1): ) #multi.set_vars(paral_kgb=1) scf_input, nscf_input, scr_input, sigma_input = multi.split_datasets() work = flowtk.G0W0Work(scf_input, nscf_input, scr_input, sigma_input) flow.register_work(work) return flow
def build_flow(options): """ Create a `Flow` for phonon calculations with phonopy: """ # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.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") # Build input for GS calculation. gsinp = abilab.AbinitInput(structure, pseudos) gsinp.set_vars(ecut=4, nband=4, toldff=1.e-6) # This gives ngkpt = 4x4x4 with 4 shifts for the initial unit cell. # The k-point sampling will be rescaled when we build the supercell in PhonopyWork. gsinp.set_autokmesh(nksmall=4) #gsinp.set_vars(ngkpt=[4, 4, 4]) flow = flowtk.Flow(workdir=options.workdir) # Use a 2x2x2 supercell to compute phonons with phonopy work = PhonopyWork.from_gs_input(gsinp, scdims=[2, 2, 2]) 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_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace( ".py", "").replace("run_", "flow_") # Init structure from internal database. structure = abidata.structure_from_ucell("MgB2") # Our pseudopotentials. pseudos = abilab.PseudoTable(["Mg-low.psp8", "B.psp8"]) flow = flowtk.Flow(workdir=options.workdir) # Build work of GS task. Each gs_task uses different (ngkpt, tsmear) values # and represent the starting point of the phonon works. ngkpt = [12, 12, 12] tsmear = 0.02 scf_input, nscf_input = make_scf_nscf_inputs(structure, ngkpt, tsmear, pseudos) gs_work = flowtk.Work() scf_task = gs_work.register_scf_task(scf_input) nscf_task = gs_work.register_nscf_task(nscf_input, deps={scf_task: "DEN"}) flow.register_work(gs_work) # This call uses the information reported in the GS task to # compute all the independent atomic perturbations corresponding to a [6, 6, 6] q-mesh. ph_work = flowtk.PhononWork.from_scf_task(scf_task, qpoints=[4, 4, 4], is_ngqpt=True) flow.register_work(ph_work) return flow.allocate(use_smartio=True)
def build_flow(options): """ Create a `Flow` for phonon calculations. The flow has one work with: - 1 GS Task - 3 DDK Task - 4 Phonon Tasks (Gamma point) - 6 Elastic tasks (3 uniaxial + 3 shear strain) The Phonon tasks and the elastic task will read the DDK produced at the beginning """ # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: if os.getenv("READTHEDOCS", False): __file__ = os.path.join(os.getcwd(), "run_elastic.py") options.workdir = os.path.basename(__file__).replace( ".py", "").replace("run_", "flow_") flow = flowtk.Flow(workdir=options.workdir) # Build input for GS calculation and register the first work. scf_input = make_scf_input() elast_work = flowtk.ElasticWork.from_scf_input(scf_input, with_relaxed_ion=True, with_piezo=True) flow.register_work(elast_work) return flow
def build_flow(options): """ Create a `Flow` for phonon calculations. The flow has two works. The first work contains a single GS task that produces the WFK file used in DFPT The second work contains multiple PhononTasks that are generated automatically in order to compute the dynamical matrix on a [4, 4, 4] mesh. Symmetries are taken into account: only q-points in the IBZ are generated and for each q-point only the independent atomic perturbations are computed. """ # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(__file__).replace(".py", "").replace("run_", "flow_") flow = flowtk.Flow(workdir=options.workdir) # Build input for GS calculation and register the first work. scf_input = make_scf_input() work0 = flow.register_scf_task(scf_input) # This call uses the information reported in the GS task (work0[0]) to # compute all the independent atomic perturbations corresponding to a [4, 4, 4] q-mesh. ph_work = flowtk.PhononWork.from_scf_task(work0[0], qpoints=[4, 4, 4], is_ngqpt=True) flow.register_work(ph_work) return flow
def build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(sys.argv[0]).replace( ".py", "").replace("run_", "flow_") structure = abidata.structure_from_ucell("MgB2") # Get pseudos from a table. table = abilab.PseudoTable(abidata.pseudos("12mg.pspnc", "5b.pspnc")) pseudos = table.get_pseudos_for_structure(structure) flow = flowtk.Flow(workdir=options.workdir) # Build work of GS task. Each gs_task uses different (ngkpt, tsmear) values # and represent the starting point of the phonon works. scf_work = flowtk.Work() ngkpt_list = [[4, 4, 4], [8, 8, 8]] #, [12, 12, 12]] tsmear_list = [0.01, 0.02] # , 0.04] for ngkpt in ngkpt_list: for tsmear in tsmear_list: scf_input = make_scf_input(structure, ngkpt, tsmear, pseudos) scf_work.register_scf_task(scf_input) flow.register_work(scf_work) # This call uses the information reported in the GS task to # compute all the independent atomic perturbations corresponding to a [2, 2, 2] q-mesh. # For each GS task, construct a phonon work that will inherit (ngkpt, tsmear) from scf_task. for scf_task in scf_work: ph_work = flowtk.PhononWork.from_scf_task(scf_task, qpoints=[2, 2, 2], is_ngqpt=True) flow.register_work(ph_work) return flow.allocate(use_smartio=True)
def build_flow(options): # Working directory (default is the name of the script with '.py' removed and "run_" replaced by "flow_") if not options.workdir: options.workdir = os.path.basename(__file__).replace(".py", "").replace("run_", "flow_") structure = abidata.structure_from_ucell("MgB2") # Get pseudos from a table. table = abilab.PseudoTable(abidata.pseudos("12mg.pspnc", "5b.pspnc")) pseudos = table.get_pseudos_for_structure(structure) nval = structure.num_valence_electrons(pseudos) #print(nval) flow = flowtk.Flow(workdir=options.workdir) scf_work = flowtk.Work() ngkpt_list = [[4, 4, 4], [8, 8, 8], [12, 12, 12]] tsmear_list = [0.01, 0.02, 0.04] for ngkpt in ngkpt_list: for tsmear in tsmear_list: scf_input = make_scf_input(structure, ngkpt, tsmear, pseudos) scf_work.register_scf_task(scf_input) flow.register_work(scf_work) # This call uses the information reported in the GS task to # compute all the independent atomic perturbations corresponding to a [4, 4, 4] q-mesh. for scf_task in scf_work: ph_work = flowtk.PhononWork.from_scf_task(scf_task, qpoints=[4, 4, 4], is_ngqpt=True) flow.register_work(ph_work) return flow.allocate(use_smartio=True)
def itest_relaxation_with_target_dilatmx(fwp, tvars): """Test structural relaxations with automatic restart from DEN files.""" # Build the flow flow = flowtk.Flow(fwp.workdir, manager=fwp.manager) # Use small value for ntime to trigger restart, then disable the output of the WFK file. ion_input, ioncell_input = make_ion_ioncell_inputs(tvars, dilatmx=1.05) target_dilatmx = 1.03 relax_work = flowtk.RelaxWork(ion_input, ioncell_input, target_dilatmx=target_dilatmx) flow.register_work(relax_work) assert flow.make_scheduler().start() == 0 flow.show_status() assert all(work.finalized for work in flow) assert flow.all_ok #assert relax_work.last_dilatmx <= target_dilatmx # we should have (0, 1) restarts for i, task in enumerate(relax_work): assert task.status == task.S_OK assert task.num_restarts == i assert task.num_corrections == 0 assert relax_work[1].input["dilatmx"] == 1.03 flow.rmtree()
def itest_relaxation_with_restart_from_den(fwp, tvars): """Test structural relaxations with automatic restart from DEN files.""" # Build the flow flow = flowtk.Flow(fwp.workdir, manager=fwp.manager) # Use small value for ntime to trigger restart, then disable the output of the WFK file. ion_input, ioncell_input = make_ion_ioncell_inputs(tvars, dilatmx=1.1, ntime=3) ion_input.set_vars(prtwf=0) ioncell_input.set_vars(prtwf=0) relax_work = flowtk.RelaxWork(ion_input, ioncell_input) flow.register_work(relax_work) assert flow.make_scheduler().start() == 0 flow.show_status() assert all(work.finalized for work in flow) assert flow.all_ok # we should have (0, 1) restarts and no WFK file in outdir. for i, task in enumerate(relax_work): assert task.status == task.S_OK assert task.num_restarts == i assert task.num_corrections == 0 assert not task.outdir.has_abiext("WFK") if has_matplotlib: assert relax_work.plot_ion_relaxation(show=False) is not None assert relax_work.plot_ioncell_relaxation(show=False) is not None flow.rmtree()
def itest_dilatmx_error_handler(fwp, tvars): """ Test cell relaxation with automatic restart in the presence of dilatmx error. """ # Build the flow flow = flowtk.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 = flowtk.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 > 0 assert t0.corrections[0]["event"]["@class"] == "DilatmxError"
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 pseudos and Structure. pseudos = abidata.pseudos("14si.pspnc") structure = abilab.Structure.from_file(abidata.cif_file("si.cif")) kppa = scf_kppa = 1 nscf_nband = 6 nscf_ngkpt = [4, 4, 4] nscf_shiftk = [0.1, 0.2, 0.3] bs_loband = 2 bs_nband = nscf_nband mbpt_sciss = 0.7 mdf_epsinf = 12 ecuteps = 2 ecut = 12 flow = flowtk.Flow(workdir=workdir, manager=options.manager, remove=options.remove) # BSE calculation with model dielectric function. multi = abilab.bse_with_mdf_inputs( structure, pseudos, scf_kppa, nscf_nband, nscf_ngkpt, nscf_shiftk, ecuteps, bs_loband, bs_nband, mbpt_sciss, mdf_epsinf, ecut=ecut, #$ pawecutdg=None, exc_type="TDA", bs_algo="haydock", accuracy="normal", spin_mode="unpolarized", smearing=None) #smearing="fermi_dirac:0.1 eV", charge=0.0, scf_algorithm=None) work = flowtk.BseMdfWork(scf_input=multi[0], nscf_input=multi[1], bse_inputs=multi[2:]) #from pymatgen.io.abinit.calculations import bse_with_mdf_work #work = bse_with_mdf_work(structure, pseudos, scf_kppa, nscf_nband, nscf_ngkpt, nscf_shiftk, # ecuteps, bs_loband, bs_nband, mbpt_sciss, mdf_epsinf, # accuracy="normal", spin_mode="unpolarized", smearing=None, # charge=0.0, scf_solver=None, **extra_abivars) flow.register_work(work) return flow