Source code for abipy.flowtk.dfpt_works

# coding: utf-8
"""Work subclasses related to DFTP."""

from .works import Work, MergeDdb

[docs]class ElasticWork(Work, MergeDdb): """ This Work computes the elastic constants and (optionally) the piezoelectric tensor. It consists of Response function calculations for: * rigid-atom elastic tensor * rigid-atom piezoelectric tensor * interatomic force constants at gamma * Born effective charges The structure is assumed to be already relaxed Create a `Flow` for phonon calculations. The flow has one works 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 """
[docs] @classmethod def from_scf_input(cls, scf_input, with_relaxed_ion=True, with_piezo=False, with_dde=False, tolerances=None, den_deps=None, manager=None): """ Args: scf_input: with_relaxed_ion: with_piezo: with_dde: Compute electric field perturbations. tolerances: Dict of tolerances den_deps: manager: Similar to `from_scf_task`, the difference is that this method requires an input for SCF calculation instead of a ScfTask. All the tasks (Scf + Phonon) are packed in a single Work whereas in the previous case we usually have multiple works. """ if tolerances is None: tolerances = {} new = cls(manager=manager) # Register task for WFK0 calculation (either SCF or NCSCF if den_deps is given) if den_deps is None: wfk_task = new.register_scf_task(scf_input) else: tolwfr = 1.0e-20 if "nscf" in tolerances: tolwfr = tolerances["nscf"]["tolwfr"] nscf_input = scf_input.new_with_vars(iscf=-2, tolwfr=tolwfr) wfk_task = new.register_nscf_task(nscf_input, deps=den_deps) if with_piezo or with_dde: # Calculate the ddk wf's needed for piezoelectric tensor and Born effective charges. #ddk_tolerance = {"tolwfr": 1.0e-20} ddk_tolerance = tolerances.get("ddk", None) ddk_multi = scf_input.make_ddk_inputs(tolerance=ddk_tolerance, manager=manager) ddk_tasks = [] for inp in ddk_multi: ddk_task = new.register_ddk_task(inp, deps={wfk_task: "WFK"}) ddk_tasks.append(ddk_task) ddk_deps = {ddk_task: "DDK" for ddk_task in ddk_tasks} if with_dde: # Add tasks for electric field perturbation. #dde_tolerance = None dde_tolerance = tolerances.get("dde", None) dde_multi = scf_input.make_dde_inputs(tolerance=dde_tolerance, use_symmetries=True, manager=manager) dde_deps = {wfk_task: "WFK"} dde_deps.update(ddk_deps) for inp in dde_multi: new.register_dde_task(inp, deps=dde_deps) # Build input files for strain and (optionally) phonons. #strain_tolerance = {"tolvrs": 1e-10} strain_tolerance = tolerances.get("strain", None) strain_multi = scf_input.make_strain_perts_inputs(tolerance=strain_tolerance, manager=manager, phonon_pert=with_relaxed_ion, kptopt=2) if with_relaxed_ion: # Phonon perturbation (read DDK if piezo). ph_deps = {wfk_task: "WFK"} if with_piezo: ph_deps.update(ddk_deps) for inp in strain_multi: if inp.get("rfphon", 0) == 1: new.register_phonon_task(inp, deps=ph_deps) # Finally compute strain pertubations (read DDK if piezo). elast_deps = {wfk_task: "WFK"} if with_piezo: elast_deps.update(ddk_deps) for inp in strain_multi: if inp.get("rfstrs", 0) != 0: new.register_elastic_task(inp, deps=elast_deps) return new
[docs] def on_all_ok(self): """ This method is called when all the tasks of the Work reach S_OK. Ir runs `mrgddb` in sequential on the local machine to produce the final DDB file in the outdir of the `Work`. """ # Merge DDB files. out_ddb = self.merge_ddb_files(delete_source_ddbs=False, only_dfpt_tasks=False) results = self.Results(node=self, returncode=0, message="DDB merge done") return results
[docs]class NscfDdksWork(Work): """ This work requires a DEN file and computes the KS energies with a non self-consistent task with a dense k-mesh and empty states. This task is then followed by the computation of the DDK matrix elements with nstep = 1 (the first order change of the wavefunctions is not converged but we only need the matrix elements) Mainly used to prepare optic calculations or other post-processing steps requiring the DDKs. """
[docs] @classmethod def from_scf_task(cls, scf_task, ddk_ngkpt, ddk_shiftk, ddk_nband, manager=None): """ Build NscfDdksWork from a scf_task. Args: scf_task: GS task. Must produce the DEN file required for the NSCF run. ddk_ngkpt: k-mesh used for the NSCF run and the non self-consistent DDK tasks. ddk_shiftk: k-mesh shifts ddk_nband: Number of bands (occupied + empty) used in the NSCF task and the DDKs tasks. manager: TaskManager instance. Use default if None. Return: NscfDdksWork instance """ new = cls(manager=manager) # NSCF task with nband states and points in the IBZ (note kptopt = 1) nscf_inp0 = scf_task.input.deepcopy() nscf_inp0.set_vars(nband=ddk_nband, prtwf=1) nscf_inp0.set_kmesh(ddk_ngkpt, ddk_shiftk, kptopt=1) nscf_task0 = new.register_nscf_task(nscf_inp0, deps={scf_task: "DEN"}) # NSCF run with nband states and points in the IBZ defined by time-reversal only (as required by DDK) # This is gonna be quick because Abinit will symmetrize states from the previous WFK file. # Time-reversal symmetry can be used in optic. #nscf_inp1 = nscf_inp0.deepcopy() #nscf_inp0.set_kmesh(ddk_ngkpt, ddk_shiftk, kptopt=2) #nscf_task1 = new.register_nscf_task(nscf_inp1) # This is the task producing the KS energies for optic new.task_with_ks_energies = nscf_task0 # Build task for one-shot DDKs (note kptopt 2) ddk_inputs = nscf_inp0.make_ddk_inputs(kptopt=2) new.ddk_tasks = [] for ddk_inp in ddk_inputs: # FIXME: prtwfk should be set to 0 but need to replace ddk_inp.set_vars(nstep=1, nline=0, prtwf=1) #new.register_ddk_task(ddk_inp, deps={nscf_task0: "WFK"}) # FIXME: Here I have a conflict with and DDK t = new.register_task(ddk_inp, deps={nscf_task0: "WFK"}) new.ddk_tasks.append(t) return new