Workflows

This section describes the aiida-kkr workflows.

Generate KKR start potential

In this module you find the base workflow for a dos calculation and some helper methods to do so with AiiDA

class aiida_kkr.workflows.voro_start.kkr_startpot_wc(*args: Any, **kwargs: Any)

Workchain create starting potential for a KKR calculation by running voronoi and getting the starting DOS for first checks on the validity of the input setting. Starts from a structure together with a KKR parameter node.

Parameters:

• wf_parameters – (Dict), Workchain specifications

• options – (Dict), specifications for the computer

• structure – (StructureData), aiida structure node to begin calculation from (needs to contain vacancies, if KKR needs empty spheres)

• kkr – (Code)

• voronoi – (Code)

• calc_parameters – (Dict), KKR parameter set, passed on to voronoi run.

Return result_kkr_startpot_wc:

(Dict), Information of workflow results like Success, last result node, dos array data

check_dos()

Checks if dos of starting potential is ok.

check_voronoi()

Check voronoi output.

return True/False if voronoi output is ok/problematic if output is problematic try to increase some parameters (e.g. cluster radius) and rerun up tp N_rerun_max times initializes with returning True

classmethod define(spec)

Defines the outline of the workflow.

do_iteration_check()

Check if another iteration should be done.

error_handler()

Capture errors raised in validate_input

find_cluster_radius_alat()

Find an estimate for the cluster radius.

The radius is chosen such that it comes close to having nclsmin atoms in the cluster.

get_dos()

Call dos sub workflow and pass the input and submit the calculation.

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary.

Can be used to easily create set of wf_parameters. returns _wf_defaults

return_results()

Return the results of the dos calculations

This should run through and produce output nodes even if everything failed, therefore it only uses results from context.

run_voronoi()

Run voronoi calculation with parameters from input.

start()

init context and some parameters

aiida_kkr.workflows.voro_start.update_voro_input(params_old, updatenode, voro_output)

Pseudo wf used to keep track of updated parameters in voronoi calculation.

voro_output only enters as dummy argument for correct connection but logic using this value is done somewhere else.

KKR scf cycle

In this module you find the base workflow for converging a kkr calculation and some helper methods to do so with AiiDA

aiida_kkr.workflows.kkr_scf.create_scf_result_node(**kwargs)

This is a pseudo wf, to create the right graph structure of AiiDA.

This workfunction will create the output node in the database. It also connects the output_node to all nodes the information commes from. So far it is just also parsed in as argument, because so far we are to lazy to put most of the code overworked from return_results in here.

aiida_kkr.workflows.kkr_scf.get_site_symbols(structure)

extract the site number taking into account a possible CPA structure

class aiida_kkr.workflows.kkr_scf.kkr_scf_wc(*args: Any, **kwargs: Any)

Workchain for converging a KKR calculation (SCF).

It converges the charge potential. Two paths are possible:

(1) Start from a structure and run a voronoi calculation first, optional with calc_parameters (2) Start from an existing Voronoi or KKR calculation, with a remoteData

Parameters:

• wf_parameters – (Dict), Workchain Specifications

• options – (Dict); specifications for the computer

• structure – (StructureData), Crystal structure

• calc_parameters – (Dict), Voronoi/Kkr Parameters

• remote_data – (RemoteData), from a KKR, or Voronoi calculation

• voronoi – (Code)

• kkr – (Code)

Return output_kkr_scf_wc_para:

(Dict), Information of workflow results like Success, last result node, list with convergence behavior

minimum input example: 1. Code1, Code2, Structure, (Parameters), (wf_parameters) 2. Code2, remote_data, (Parameters), (wf_parameters)

maximum input example: 1. Code1, Code2, Structure, Parameters

wf_parameters: {‘queue_name’String,

‘resources’ : dict({“num_machines”: int, “num_mpiprocs_per_machine” : int}) ‘walltime’ : int}

2. Code2, (remote-data), wf_parameters as in 1.

Hints: 1. This workflow does not work with local codes!

_get_new_noco_angles()

Extract nonco angles from output of calculation.

If fix_dir is True we skip this and leave the initial angles unchanged Here we update self.ctx.initial_noco_angles with the new values

adapt_emin(new_params)

Change EMIN if core states are too close.

change_conv_para(new_params, para_check, initial_settings, decrease_mixing_fac, switch_agressive_mixing, switch_higher_accuracy, label, description)

Adapt the kkr parameters to change the convergence settings and the mixing

check_dos()

Checks if dos of final potential is ok.

check_input_params(params, is_voronoi=False)

Check the input parameter consistency and aborts wf if check fails.

check_voronoi()

Check output of kkr_startpot_wc workflow.

It checks the starting potential, shapefun etc.

condition()

check convergence condition

convergence_on_track()

Check if convergence behavior of the last calculation is on track.

(i.e. going down)

classmethod define(spec)

Defines the outline of the workflow.

get_dos()

Call the dos sub workflow pass the input and submit the calculation.

classmethod get_wf_defaults(silent=False)

Print and return _wf_default dictionary.

Can be used to easily create set of wf_parameters. returns _wf_default, _options_default

initial_mag(new_params, initial_settings)

Add settings for initial magnetization

initialize_params(para_check)

Initialize new_params with missing defaults

inspect_kkr()

Check for convergence and store the results of the last calculation.

return_results()

Return the results of the calculations.

This should run through and produce output nodes even if everything failed, therefore it only uses results from context.

run_kkr()

submit a KKR calculation

run_voronoi()

Run the voronoi step calling voro_start workflow.

start()

Initialize context and some parameters.

update_kkr_params()

Update set of KKR parameters.

(check for reduced mixing, change of mixing strategy, change of accuracy setting)

validate_input()

Validate input and find out which path (1, or 2) to take

return True means run voronoi if false run kkr directly

Density of states

In this module you find the base workflow for a dos calculation and some helper methods to do so with AiiDA

class aiida_kkr.workflows.dos.kkr_dos_wc(*args: Any, **kwargs: Any)

Workchain a DOS calculation with KKR starting from the remoteData node of a previous calculation (either Voronoi or KKR).

Parameters:

• wf_parameters – (Dict); Workchain specifications

• options – (Dict); specifications for the computer

• remote_data – (RemoteData), mandatory; from a KKR or Vornoi calculation

• kkr – (Code), mandatory; KKR code running the dos calculation

Return result_kkr_dos_wc:

(Dict), Information of workflow results like Success, last result node, list with convergence behavior

classmethod define(spec)

Defines the outline of the workflow.

get_dos()

submit a dos calculation and interpolate result if returns complete

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary.

Can be used to easily create set of wf_parameters. returns _wf_defaults

return_results()

Collect results, parse DOS output and link output nodes to workflow node

set_params_dos()

take input parameter node and change to DOS contour according to input from wf_parameter input internally calls the update_params work function to keep track of provenance

start()

init context and some parameters

validate_input()

# validate input and find out which path (1, or 2) to take # return True means run voronoi if false run kkr directly

Bandstructure

This module contains the band structure workflow for KKR which is done by calculating the k-resolved spectral density also known as Bloch spectral function.

class aiida_kkr.workflows.bs.kkr_bs_wc(*args: Any, **kwargs: Any)

Workchain for BandStructure calculation, starting from RemoteFolderData of the previous converged KKR calculation remote folder data

inputs: :param wf_parameters: (Dict), (optional); Workchain Specifications, contains nepts, tempr, emin (in eV relative to EF), emax (in eV),

and RCLUSTZ (can be used to increase the screening cluster radius) keys.

Parameters:

• options – (Dict), (optional); Computer Specifications, scheduler command, parallel or serial

• kpoints – (KpointsData),(optional); Kpoints data type from the structure, but not mendatory as it can be extracted from structure internaly from the remote data

• remote_data – (RemoteData)(mendaory); From the previous kkr-converged calculation.

• kkr – (Code)(mendaory); KKR code specifiaction

• label – (Str) (optional) ; label for WC but will be found in the ‘result_wf’ output Dict as ‘BS_wf_label’ key

• description – (Str) (optional) : description for WC but will be found in the ‘result_wf’ output Dict as ‘BS_wf_description’ key

returns: :out BS_Data : (ArrayData) ; Consist of BlochSpectralFunction, k_points (list), energy_points (list), special_kpoints(dict) :out result_wf: (Dict); work_chain_specifications node, BS_data node, remote_folder node

classmethod define(spec)

Layout of the workflow, defines the input nodes and the outline of the workchain

get_BS()

submit the KkrCalcultion with the qdos settings for a bandstructure calculation

classmethod get_wf_defaults(silent=False)

Return the default values of the workflow parameters (wf_parameters input node)

return_results()

Collect results, parse BS_calc output and link output nodes to workflow node

set_params_BS()

set kkr parameters for the bandstructure (i.e. qdos) calculation

start()

set up context of the workflow

validate_input()

validate input and find out which path ( converged kkr calc or wf ) to take return True means run voronoi if false run kkr directly

aiida_kkr.workflows.bs.parse_BS_data(retrieved_folder, fermi_level, kpoints)

parse the qdos files from the retreived folderand save as ArrayData

aiida_kkr.workflows.bs.set_energy_params(econt_new, ef, para_check)

set energy contour values to para_check internally convert from relative eV units to absolute Ry units

Equation of states

In this module you find the base workflow for a EOS calculation and some helper methods to do so with AiiDA

aiida_kkr.workflows.eos.get_primitive_structure(structure, return_all)

calls get_explicit_kpoints_path which gives primitive structure auxiliary workfunction to keep provenance

class aiida_kkr.workflows.eos.kkr_eos_wc(*args: Any, **kwargs: Any)

Workchain of an equation of states calculation with KKR.

Layout of the workflow:

1. determine V0, scale_range, etc. from input

2. run voro_start for V0 and smallest volume

   2.1 get minimum for RMTCORE (needs to be fixed for all calculations to be able to compare total energies

3. submit kkr_scf calculations for all volumes using RMTCORE setting determined in step 2

4. collect results

check_voro_out()

Check output of the vorostart workflow.

The outputs are then used to create inputs for the next set of calculations (rmtcore setting etc.)

collect_data_and_fit()

Collect output of KKR calculations and perform eos fitting.

classmethod define(spec)

Defines the outline of the workflow.

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary.

Can be used to easily create set of wf_parameters. returns _wf_defaults, _options_default

prepare_strucs()

Create new set of scaled structures for the E-V curve.

The structures are generated using the ‘rescale’ workfunction (see end of the workflow)

return_results()

Create output dictionary and run output node generation.

run_kkr_steps()

Submit KKR calculations for all structures.

This will skip the vorostart step for smallest structure.

run_vorostart()

Run vorostart workflow for smallest structure to determine rmtcore.

One needs to run all the calculations with the same rmtcore to be able to compare the energies. This value is then set for all others.

start()

initialize context and check input nodes

aiida_kkr.workflows.eos.rescale(inp_structure, scale)

Rescales a crystal structure. Keeps the provenance in the database.

:param inp_structure, a StructureData node (pk, or uuid) :param scale, float scaling factor for the cell

Returns:

New StructureData node with rescalled structure, which is linked to input Structure and None if inp_structure was not a StructureData

copied and modified from aiida_fleur.tools.StructureData_util

aiida_kkr.workflows.eos.rescale_no_wf(structure, scale) → StructureData

Rescales a crystal structure. DOES NOT keep the provenance in the database.

:param structure, a StructureData node (pk, or uuid) :param scale, float scaling factor for the cell

Returns:

New StructureData node with rescalled structure, which is linked to input Structure and None if inp_structure was not a StructureData

copied and modified from aiida_fleur.tools.StructureData_util

Find Green Function writeout for KKRimp

In this module you find the base workflow for writing out the kkr_flexfiles and some helper methods to do so with AiiDA

class aiida_kkr.workflows.gf_writeout.kkr_flex_wc(*args: Any, **kwargs: Any)

Workchain of a kkr_flex calculation to calculate the Green function with KKR starting from the RemoteData node of a previous calculation (either Voronoi or KKR).

Parameters:

• options – (Dict), Workchain specifications

• wf_parameters – (Dict), Workflow parameters that deviate from previous KKR RemoteData

• remote_data – (RemoteData), mandatory; from a converged KKR calculation

• kkr – (Code), mandatory; KKR code running the flexfile writeout

• impurity_info – Dict, mandatory: node specifying information of the impurities in the system

Return workflow_info:

(Dict), Information of workflow results like success, last result node, list with convergence behavior

Return GF_host_remote:

(RemoteData), host GF of the system

classmethod define(spec)

Defines the outline of the workflow

get_flex()

Submit a KKRFLEX calculation

classmethod get_wf_defaults()

Print and return _wf_defaults dictionary. Can be used to easily create set of wf_parameters. returns _wf_defaults

move_kkrflex_files()

Move the kkrflex files from the remote folder to KkrimpCalculation._DIRNAME_GF_UPLOAD on the remote computer’s working dir. This skips retrieval to the file repository and reduces cluttering the database.

return_results()

Return the results of the KKRFLEX calculation. This should run through and produce output nodes even if everything failed, therefore it only uses results from context.

set_params_flex()

Take input parameter node and change to input from wf_parameter and options

start()

init context and some parameters

validate_input()

Validate input

KKRhost Jij calculation

This module contains the workflow that can be used to calculate the exchange coupling constants

aiida_kkr.workflows.jijs._make_nonco_angles(parent_remote)

Create nonco angles for the 3 directions (x y, z)

class aiida_kkr.workflows.jijs.kkr_jij_wc(*args: Any, **kwargs: Any)

Workchain for calculation of exchange coupling constants Jij and Dij if parent calculation used the SOC solver.

inputs:

:param wf_parameters: optional Dict node of workchain specifications, contains settings like Jij radius cutoff,
                      selection of sites for i and j and numerical cutoffs. None values in the accuracy sub-dict
                      means that values from parent calculation are coptied.
:param remote_data: mandatory RemoteData node of parent (i.e. converged) KkrCalculation
:param kkr: optional Code for KKRhost executable (if not given the same as in the parent calculation is used)
:param options: optional Dict computer options like scheduler command or parallelization

returns:

:return jij_data: ArrayData with the arrays 'Jij_expanded' (Table of all Jij and Dij pairs) and 'positions_expanded' (positions of all ij pairs)
:return structure_jij_sites: StructureData

_get_jijrad()

get Jij radius convert from Ang to internal alat units

_get_para_jij(params)

Set the Jij parameters from the input. Returns a kkrparams instance with the set values

classmethod define(spec)

Layout of the workflow, defines the input nodes and the outline of the workchain

classmethod get_wf_defaults(silent=False)

Return the default values of the workflow parameters (wf_parameters input node)

return_results()

Collect results, parse Jij output and link output nodes to workflow node

set_jij_params()

set kkr parameters for the Jij calculation

start()

set up context of the workflow

submit_Jij_calcs()

submit the KkrCalcultion with the Jij settings

validate_input()

validate inputs

KKRhost semi-finite (decimation) calculation

In this module you find the workflow that does a decimation calculation for half-infinite crystals

aiida_kkr.workflows._decimation._adapt_array_sizes(params_dict, pick_layers)

Check the params dict for array entries which should be changed to the correct size.

This is needed because the decimation region is smaller than the parent slab structure and the substrate only uses a part from the middle of the arrays.

aiida_kkr.workflows._decimation._make_d_deci(d, struc_deci, params_overwrite, slab_alat, use_left=True)

Create the input parameters for the substrate calculation

aiida_kkr.workflows._decimation._make_d_substrate(d, params_overwrite, slab_alat, nkz)

Create the input parameters for the substrate calculation

aiida_kkr.workflows._decimation.get_deci_structure(nprinc, nplayer, slab_calc, use_left=True)

calcfunction that creates the decimation structure

aiida_kkr.workflows._decimation.get_noco_angles_deci(init_noco_slab, struc_decimation, struc_substrate, use_left=True)

create noco angles for substrate and decimation regions from initial angles of slab calc

aiida_kkr.workflows._decimation.get_substrate_structure(nprinc, nplayer, slab_calc, use_left=True)

calcfunction that creates the decimation structure

class aiida_kkr.workflows._decimation.kkr_decimation_wc(*args: Any, **kwargs: Any)

Workchain a decimation calculation with KKR starting from a thick slab (center potential should be bulk-like).

The workchain

• creates the structure nodes of the substrate and decimation region from thick slab structure

• creates starting potentials of the slab structure

• runs auxiliary voronoi steps to get starting setup correctly for the KKR calculations

• runs the deci-out step in serial

• runs the decimation step

The workflow starts either from a converged thick film of from a previous decimation calculation (skips the structure and starting potential setup and the voronoi steps).

The workflow parameters input can be:

{‘nkz’30, # number of k-points in z-direction for substrate

‘nprinc’: 4, # number of layer in principle layer ‘nplayer’: 4, # number of principle layers (naez deci: nprinc*nplayer) ‘dosmode’: False, # run DOS calculation ‘dos_params’: {‘emin_EF’: -5.0, # EMIN-EF in eV

‘emax_EF’: 3.0, # EMAX-EF in eV ‘nepts’: 96, # number of points in contour ‘tempr’: 100, # smearing temperature ‘kmesh’: [50, 50, 50]}, # k-mesh used in dos calculation

}

Parameters:

• wf_parameters – Dict node with workchain parameters (see kkr_decimation_wc.get_wf_defaults())

• options – Dict node with specifications for the computer (used in decimation step only)

• remote_data – mandatory RemoteData node of either a parent slab or previous decimation calculation

• kkr – mandatory Code node with KKR code for running deci-out and decimation steps

• voronoi – Code node that is mandatory if starting from slab calculation. Is the voronoi code for auxiliary calculations

• kpoints – KpointsData node that triggers a band structure calculation. The kpoints specify the k-point path along which the bandstructure is computed with the qdos mode of KKRhost.

• calc_parameters – Dict node that contains KKR parameters which overwrites settings from the slab parent.

Returns structure_decimate:

StructureData node of the structure of the decimation region.

Returns structure_substrate:

StructureData node of the structure of thesubstrate lattice continuation.

Returns out_params_calc_deci_out:

Dict node of the output parameters of the deci-out calculation.

Returns out_params_calc_decimate:

Dict node of the output parameters of the decimation calculation.

Returns out_remote_calc_decimate:

RemoteData node of the decimation calculation.

Returns out_retrieved_calc_decimate:

retrieved FolderData node of the decimation calculation.

Returns dos_data:

XyData node with the DOS data at finite imaginary part in the energy contour. Only present in DOS mode.

Returns dos_data_interpol:

XyData node with the interpolated DOS data onto the real axis. Only present in DOS mode.

_create_startpots()

create substrate and slab potentials from slab calculation

_create_structures()

create substrate and slab structures for deci-out and decimation steps

_get_adens_decimate()

Extract the correct anomalous density which is used for the decimation region

_get_adens_substrate()

Extract the correct anomalous density which is used for the substrate

classmethod define(spec)

Defines the outline of the workflow.

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary. Can be used to easily create set of wf_parameters. returns _wf_defaults

prepare_deci_from_slab()

prepare deci-out and decimation steps (creates structure and startpot)

return_results()

check if the calculation was successful and return the result nodes

run_decimation()

run KKR calculation for decimation step

run_deciout()

run KKR calculation for deci-out step

run_voroaux()

run auxiliary voronoi steps if needed

start()

init context and some parameters

validate_input()

# validate input and find out which path (starting from slab of previous decimation calc) to take

aiida_kkr.workflows._decimation.make_decimation_param_nodes(slab_calc_params, slab_alat, struc_deci, struc_substrate, nkz, params_overwrite=None, params_overwrite_decimate=None, use_left=True)

Create parameter nodes for deci-out and decimation steps

KKRimp self-consistency

In this module you find the sub workflow for the kkrimp self consistency cycle and some helper methods to do so with AiiDA

aiida_kkr.workflows.kkr_imp_sub.extract_imp_pot_sfd(retrieved_folder)

Extract potential file from retrieved folder and save as SingleFileData

class aiida_kkr.workflows.kkr_imp_sub.kkr_imp_sub_wc(*args: Any, **kwargs: Any)

Workchain of a kkrimp self consistency calculation starting from the host-impurity potential of the system. (Not the entire kkr_imp workflow!)

Parameters:

• options – (Dict), Workchain specifications

• wf_parameters – (Dict), specifications for the calculation

• host_imp_startpot – (RemoteData), mandatory; input host-impurity potential

• kkrimp – (Code), mandatory; KKRimp code converging the host-imp-potential

• remote_data – (RemoteData), mandatory; remote folder of a previous kkrflex calculation containing the flexfiles …

• kkrimp_remote – (RemoteData), remote folder of a previous kkrimp calculation

• impurity_info – (Dict), Parameter node with information about the impurity cluster

Return workflow_info:

(Dict), Information of workflow results like success, last result node, list with convergence behavior

Return host_imp_pot:

(SinglefileData), output potential of the sytem

_overwrite_parameters_from_input(new_params)

Overwrite input parameters for KKRimpCalculation if found in input

condition()

check convergence condition

convergence_on_track()

Check if convergence behavior of the last calculation is on track (i.e. going down)

classmethod define(spec)

Defines the outline of the workflow

error_handler()

Capture errors raised in validate_input

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary. Can be used to easily create set of wf_parameters.

returns _wf_defaults

inspect_kkrimp()

check for convergence and store some of the results of the last calculation to context

return_results()

Return the results of the calculations This should run through and produce output nodes even if everything failed, therefore it only uses results from context.

run_kkrimp()

submit a KKR impurity calculation

start()

init context and some parameters

update_kkrimp_params()

update set of KKR parameters (check for reduced mixing, change of mixing strategy, change of accuracy setting)

validate_input()

validate input and catch possible errors from the input

KKRimp complete calculation

In this module you find the total workflow for a kkr impurity calculation and some helper methods to do so with AiiDA

class aiida_kkr.workflows.kkr_imp.kkr_imp_wc(*args: Any, **kwargs: Any)

Workchain of a kkrimp calculation starting either from scratch (with a structure and impurity_info node), or with a converged host potential and impurity startpotentials, … to calculate the converged host-impurity potential of the system.

Parameters:

• options – (Dict), Workchain specifications

• wf_parameters – (Dict), specifications for the kkr impurity workflow

• voro_aux_parameters – (Dict), specification for the auxiliary voronoi calculation for the impurity

• kkrimp – (Code), mandatory: KKRimp code converging the host-imp-potential

• kkr – (Code), mandatory: KKR code for calculation the host potential

• voronoi – (Code), mandatory: Voronoi code to generate the impurity startpot

• remote_data_gf – (RemoteData): remote folder of a previous kkrflex calculation containing the flexfiles …

• remote_data_host – (RemoteData): remote folder of a converged KKR host calculation

Return workflow_info:

(Dict), Information of workflow results

Return last_calc_output_parameters:

(Dict), output parameters of the last called calculation

Return last_calc_info:

(Dict), information of the last called calculation

construct_startpot()

Take the output of GF writeout and the converged host potential as well as the auxiliary startpotentials for the impurity to construct the startpotential for the KKR impurity sub workflow

classmethod define(spec)

Defines the outline of the workflow

error_handler()

Capture errors raised in validate_input

get_ef_from_parent()

Extract Fermi level in Ry to which starting potential is set

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary. Can be used to easily create set of wf_parameters.

returns _wf_defaults

has_starting_potential_input()

check whether or not a starting potential needs to be created

return_results()

Return the results and create all of the output nodes

run_gf_writeout()

Run the gf_writeout workflow to calculate the host Green’s function and the KKR flexfiles using the converged host remote folder and the impurity info node

run_kkrimp_scf()

Uses both the previously generated host-impurity startpotential and the output from the GF writeout workflow as inputs to run the kkrimp_sub workflow in order to converge the host-impurity potential

run_voroaux()

Perform a voronoi calculation for every impurity charge using the structure from the converged KKR host calculation

start()

Init context and some parameters

validate_input()

Validate the input and catch possible errors from the input

KKRimp combine impurities to larger imp. cluster

This module contains the workflow which combines pre-converged two single-impurity calculations to a larger impurity calculation

class aiida_kkr.workflows._combine_imps.combine_imps_wc(*args: Any, **kwargs: Any)

Workchain that combines 2 converged single-impurity calculations to a bigger impurity, reusing the preconverged potentials. This is useful, for example, to study co-doping.

Inputs:

:param impurity1_output_node:(Dict), required, output node from singel impurity wc, and should be one of the

following: * for kkr_imp_wc: single_imp_worlfow.outputs.workflow_info * for kkr_imp_sub_wc: single_imp_worlfow.outputs.workflow_info * for KkrimpCalculation: single_imp_worlfow.outputs.output_parameters

:param impurity2_output_node:(Dict), required, output node from second singel impurity wc, and should be one of

the following: * for kkr_imp_wc: single_imp_worlfow.outputs.workflow_info * for kkr_imp_sub_wc: single_imp_worlfow.outputs.workflow_info * for KkrimpCalculation: single_imp_worlfow.outputs.output_parameters

:offset_imp2:(Dict), required, offset of the second impurity with respect to the first impurity position.

e.g. {‘index:0 or 1}, the replacement by the second impurity will take place at the same cell

or at the next nearest cell respectively.

param scf.kkrimp:

(Code), mandatory, KKRimp code needed to submit kkr_imp_wc

param scf.wf_parameters:

(Dict), optional, KKRimp code needed to submit kkr_imp_sub_wc

param scf.options:

(Dict), optional, computer options for kkr_imp_sub_wc

param host_gf.kkr:

(Code), optional, KKR code for submit kkr_flex_wc, needed if remote_data_gf is not given

param host_gf.options:

(Dict), optional, computer options for kkr_flex_wc

param host_gf.params_kkr_overwrite:

(Dict), optional, needed for kkr calculation for GF writeout

param wf_parameters_overwrite:

(Dict), optional, specifications for wf_parameters of kkr_imp_sub_wc as well as well as wf_parameters of kkr_flex_wc.

param gf_host_remote:

(RemoteData), optional, remote folder of a previous kkrflex writeout step calculations containing the flexfiles and will be used for combine host GF.

Returns:

return workflow_info:

(Dict), Information of workflow results

return last_calc_output_parameters:

(Dict), link to output parameters of the last called calculation of the scf kkr_imp_sub_wc.

return last_potential:

(SingleFileData) link to last output potential of scf kkr_imp_sub_wc step.

return last_calc_remote:

(RemoteData) link to remote data of last called calculation of the scf step.

return remote_data_gf:

(RemoteData) link to GF_host_remote of outputs of kkr_flex_wc e.g. gf_writeou step (only present of host GF was generated here).

return JijData:

(ArrayData) Consists magnetic interaction data among the magnetic impurity atoms, such as vector distance(rx, ry, rz) between atoms, spin interaction magnetude J, Dzyaloshinskii-Moriya vector magnitude, and Dzyaloshinskii-Moriya vector component(Dx, Dy, Dz)

:return JijInfo :(Dict) Consists description about the JijData.

_check_input_imp(imp_calc_or_wf)

check if input calculation is of the right process_class and if it did converge

check_host_gf()

Check if host gf is there

combine_single_single()

This function checks whether the impurity1_output_node and the impurity2_output_node are from (kkr_imp_wc, kkr_imp_wc) or (combine_imps_wc, kkr_imp_wc), and always keeps the combine_imps_wc as the first impurity node for combine cluster.

create_big_cluster()

combine imp clusters of the two imps

create_big_potential()

combine preconverged potentials to big one

classmethod define(spec)

Defines the outline of the workflow

extract_imps_info_exact_cluster()

This method collects the all exist impurity info as in the exact crystal rather than in the crystal centering the first impurity at (0,0,0) position. Returns the imps_info_in_exact_cluster dict.

get_and_check_zimp_list(impurity_info)

extract zimp from impurity_info node and check if it is consistent (needs to be single impurity calculation)

get_imp_node_from_input(impurity_output_node=None, iimp=1)

extract impurty calculation from impurity_output_node as inputs

get_impinfo_from_hostGF(imp_calc)

Extract impurity infor node from the incoming host GF folder

get_ldau_combined()

check if impurity input calculations have LDA+U settings in input and add this here if needed

classmethod get_wf_defaults(silent=False)

Print and return _wf_defaults dictionary. Can be used to easily create set of wf_parameters_overwrite. returns _wf_defaults

imps_info_exact_cluster_2imps(single_imp1_wc, single_imp2_wc, offset_imp2)

This construct a python dict keeping info about two single inpurities with respect to the original host structure e.i. before transforming the center to the first impurity position.

need_gf_run()

check if GF was given in input and can be reused (then return Falser which means no gf needs to be calculated)

return_results()

check if the calculation was successful and return the result nodes

run_gf_writeout()

Write out the host GF

run_jij_step()

Run the jij calculation with the converged combined_imp_host_pot

run_kkrimp_scf()

run the kkrimp_sub workflow to converge the host-imp startpot

start()

prepare context, run_option, wf_parameter, run_option, wf_parameterss and do some consistency checks

update_params()

Update the parameters in scf_wf_parameters according to wf_parameters_overwrite if any change occur there and also add the run options.

aiida_kkr.workflows._combine_imps.parse_Jij(retrieved, impurity_info, impurity1_output_node, impurity2_output_node)

parser output of Jij calculation and return as ArrayData node

STM scan around impurities

class aiida_kkr.workflows.kkr_STM.kkr_STM_wc(*args: Any, **kwargs: Any)

Workchain for the Simulation of a (superconducting) STM tip around a magnetic impurity. The workchain uses the (converged) impurity calculation of a host system and combines them with vacuum sites in positions

inputs::

param options:

(Dict), computer options

param tip_position:

(Dict), specify the position of the STM tip

param impurity_info:

(Dict), information about the impurity cluster

param host_calc:

(RemoteData), information about the host structure of the sample

param wf_parameters:

(Dict), parameters that are used to run the workflow

param kkr:

(Code), KKR host code for the writing out kkrflex files

param kkrimp:

(Code), KKR impurity code for the normal state impurity scf and BdG impurity DOS calculation

:param gf_writeout.params_kkr_overwrite (Dict), overwrite parameters for the GF calculation :param kkr_imp_sub.params_overwrite (Dict), overwrite parameters for the impurity calculation

returns:

:return workflow_info: (Dict), Information of workflow results
                    like success, last result node, list with convergence behavior
:return STM_dos_data: (XYData), Returns the plot of the lmDOS of the calculation
:retrun STM_lmdos_data: (XYData), Returns the interpolated lmDOS of the calculation

STM_lmdos_run()

In this part of the worflow we want to simulate the lmdos which a STM is able to measure

classmethod define(spec)

Layout of the workflow, defines the input nodes and the outline of the workchain

get_scanning_positions(host_remote)

Extract scanning positions either from input ‘scan_positions’ or from ‘nx’, ‘ny’ + symmetry analysis

If ‘scan_positions’ is found in ‘tip_position’ input dict we use these positions which should be 2D array of integers with the positions in units of the structure’s in-plane Bravais matrix.

Otherwise we use the ‘nx’, ‘ny’ input to define a scanning region where an automated symmetry analysis is done to reduce the scanning area to the irreducible part.

classmethod get_wf_defaults(silent=False)

Print and return _wf_default dictionary.

Can be used to easily create set of wf_parameters. returns _wf_default, _options_default

impurity_cluster_evaluation()

Create the combined impurity cluster and potential for the impurity region used in self-consistency + the additional scanning sites.

results()

Collect results and return output nodes

start()

Initialise context and some parameters

validate_input()

Check if inputs are valid

Impurity embedding + calculation of YSR states in superconductors

class aiida_kkr.workflows.imp_BdG.kkrimp_BdG_wc(*args: Any, **kwargs: Any)

Workchain for one-shot BdG impurity DOS calculation from a converged normal state host calculation. 1) Normal state impurity potential scf 2) One-shot BdG DOS calcluation

1. Writing out of the BdG kkrflex DOS files

2. One-shot BdG impurity DOS

The intermediate steps (1 & 2a) can be skipped by providing the corresponding nodes as inputs to the workflow.

inputs::

param options:

(Dict), computer options

param impurity_info:

(Dict), information about the impurity cluster

param voronoi:

(Code), Voronoi code for creating the impurity starting potential

param kkr:

(Code), KKR host code for the writing out kkrflex files

param kkrimp:

(Code), KKR impurity code for the normal state impurity scf and BdG impurity DOS calculation

param BdG_settings:

(Dict), set BdG parameters

param imp_scf.startpot:

(SinglefileData), pre-converged impurity potential used to start the impurity scf calculation

param imp_scf.converged_potential:

(SinglefileData), converged impurity potential, skips the impurity scf calculation if provided

param imp_scf.wf_parameters:

(Dict), parameters for the kkr impurity scf

param imp_scf.gf_writeout.params_kkr_overwrite:

(Dict), set some input parameters of the KKR calculation for the GF writeout step of impurity scf workchain

param imp_scf.gf_writeout.options:

(Dict), computer settings

param imp_scf.scf.params_overwrite:

(Dict), set some input parameters of the KKR impurity scf

param imp_scf.options:

(Dict), computer settings

param imp_scf.remote_data_host:

(RemoteData), parent folder of converged host normal state KkrCalculation

param dos.wf_parameters:

(Dict), parameters for the DOS calculation

param dos.gf_dos_remote:

(RemoteData), node of precomputed host GF for DOS energy contour

param dos.gf_writeout.params_kkr_overwrite:

(Dict), set some input parameters of the KKR calculation for the GF writeout step of imßpurity dos workchain

param dos.gf_writeout.host_remote:

(RemoteData), parent folder of kkrflex writeout step for DOS calculation

param dos.gf_writeout.kkr:

(Code), KKR code for writing out of kkrflex files for impurity DOS calculation

param dos.gf_writeout.options:

(Dict), computer settings

param dos.options:

(Dict), computer settings

returns::

return workflow_info:

(Dict), Information on workflow results

return output_parameters:

(Dict), output parameters of the workflow

return dos_data:

(XyData), impurity DOS data output node

return dos_data_interpol:

(XyData), interpolated DOS data output node

return impurity_potential:

(SinglefileData), converged normal state impurity potential node

return gf_host_BdG:

(RemoteData), kkrflex writeout step files of DOS calculation

DOS_calc()

run DOS calculation

classmethod define(spec)

Layout of the workflow, defines the input nodes and the outline of the workchain

do_BdG_scf()

run BdG scf step only if BdG impurity potential not provided and DOS calculation is not planned

do_calc_DOS()

check if DOS calculation should be done

do_imp_pot_calc()

run impurity potential calculation only if converged impurity potential not provided already

imp_BdG_calc()

run BdG one-shot impurity calculation

imp_pot_calc()

run normal state impurity scf calculation

results()

return the results nodes of the workchain

start()

Set up context of the workflow

validate_input()

validate inputs