Fleur initial core-level shifts workflow — AiiDA-FLEUR 1.1.0 documentation

- Current version: 0.3.4

# Fleur initial core-level shifts workflow

Warning

This workchain does not work with AiiDA 1.1.0 version yet. They need to be updated.

Class name, import from:

      from aiida_fleur.workflows.initial_cls import fleur_initial_cls_wc
      #or
      WorkflowFactory('fleur.init_cls')

## Description/Purpose

> Converges the charge density and/or the total energy of a given system, or stops because the maximum allowed retries are reached.

> This workflow manages none to one inpgen calculation and one to several Fleur calculations. It is one of the most core workflows and often deployed as subworkflow.

> Note

> The fleur_wc_sc per default determines the calculation resources required for the given system and with what hybrid parallelisation to launch Fleur. The resources in the option node given are the maximum resources the workflow is allowed to allocate for one simulation (job). You can turn off this feature by setting `determine_resources = False` in the `wf_parameters`.

## Input nodes

> - `fleur` (aiida.orm.Code): Fleur code using the `fleur.fleur` plugin

> - `inpgen` (aiida.orm.Code): Inpgen code using the `fleur.inpgen` plugin

> - `wf_parameters` (ParameterData, optional): Some settings of the workflow behavior (e.g. convergence criterion, maximum number of Fleur jobs..)

> - `structure` (StructureData, path 1): Crystal structure data node.

> - `calc_parameters` (str, optional): Longer description of the workflow

> - `fleurinp` (FleurinpData, path 2): Label of the workflow

> - `remote_data` (RemoteData, optional): The remote folder of the (converged) calculation whose output density is used as input for the DOS run

> - `settings` (ParameterData, optional): special settings for Fleur calculations, will be given like it is through to calculationss.

## Returns nodes

> - `output_scf_wc_para` (ParameterData): Information of workflow results like success, last result node, list with convergence behavior

> - `fleurinp` (FleurinpData) Input node used is retunred.

> - `last_fleur_calc_output` (ParameterData) Output node of last Fleur calculation is returned.

## Layout

## Database Node graph

>     from aiida_fleur.tools.graph_fleur import draw_graph

>     draw_graph(50816)

## Plot_fleur visualization

> Single node

>     from aiida_fleur.tools.plot import plot_fleur

>     plot_fleur(50816)

> Multi node

>     from aiida_fleur.tools.plot import plot_fleur

>     plot_fleur(scf_pk_list)

## Example usage

>     # -*- coding: utf-8 -*-
>     ###############################################################################
>     # Copyright (c), Forschungszentrum Jülich GmbH, IAS-1/PGI-1, Germany.         #
>     #                All rights reserved.                                         #
>     # This file is part of the AiiDA-FLEUR package.                               #
>     #                                                                             #
>     # The code is hosted on GitHub at https://github.com/broeder-j/aiida-fleur    #
>     # For further information on the license, see the LICENSE.txt file            #
>     # For further information please visit http://www.flapw.de or                 #
>     # http://aiida-fleur.readthedocs.io/en/develop/                               #
>     ###############################################################################
>     """
>     Here we run the fleur_scf_wc for W or some other material
>     Layout:

>     1. Database env load, Import, create base classes
>     2. Creation of  input nodes
>     3. Lauch workchain
>     """

>     #######################
>     # 1. Load the database environment. Imports and base class creation

>     from __future__ import absolute_import
>     from aiida import load_dbenv, is_dbenv_loaded
>     if not is_dbenv_loaded():
>         load_dbenv()

>     from aiida.plugins import DataFactory
>     from aiida.orm import Code, load_node
>     from aiida.engine.launch import submit, run
>     from aiida_fleur.workflows.scf import FleurScfWorkChain

>     ParameterData = DataFactory('parameter')
>     StructureData = DataFactory('structure')

>     #######################
>     # 2. Creation/loding of input nodes

>     # Load the codes, thwy have to be setup in your database.
>     fleur_label = 'fleur@localhost'
>     inpgen_label = 'inpgen@localhost'
>     fleur_code = Code.get_from_string(fleur_label)
>     inpgen_code = Code.get_from_string(inpgen_label)

>     ### Create wf_parameters (optional) and options
>     wf_para = Dict(dict={'fleur_runmax': 4, 'density_criterion': 0.000001, 'serial': False})

>     options = Dict(dict={'resources': {'num_machines': 1}, 'queue_name': '', 'max_wallclock_seconds': 60 * 60})

>     # Create W bcc crystal structure
>     bohr_a_0 = 0.52917721092  # A
>     a = 3.013812049196 * bohr_a_0
>     cell = [[-a, a, a], [a, -a, a], [a, a, -a]]
>     structure = StructureData(cell=cell)
>     structure.append_atom(position=(0., 0., 0.), symbols='W')

>     # (optional) We specifi some FLAPW parameters for W
>     parameters = Dict(
>         dict={
>             'atom': {
>                 'element': 'W',
>                 'jri': 833,
>                 'rmt': 2.3,
>                 'dx': 0.015,
>                 'lmax': 8,
>                 'lo': '5p',
>                 'econfig': '[Kr] 5s2 4d10 4f14| 5p6 5d4 6s2',
>             },
>             'comp': {
>                 'kmax': 3.0,
>             },
>             'kpt': {
>                 'nkpt': 100,
>             }
>         })

>     ################################
>     # 3. submit the workchain with its inputs.

>     inputs = {}
>     inputs['wf_parameters'] = wf_para
>     inputs['structure'] = structure
>     inputs['calc_parameters'] = parameters
>     inputs['fleur'] = fleur_code
>     inputs['inpgen'] = inpgen_code
>     inputs['description'] = 'test fleur_scf_wc run on W'
>     inputs['label'] = 'test on W'
>     inputs['options'] = options

>     # submit workchain to the daemon
>     # Noice that the nodes we created before are not yet stored in the database,
>     # but AiiDA will do so automaticly when we launch the workchain.
>     # To reuse nodes it might be a good idea, to save them before by hand and then load them
>     res = submit(FleurScfWorkChain, **inputs)

>     # You can also run the workflow in the python interpreter as blocking
>     #res = run(fleur_scf_wc, **inputs)

## Output node example

## Error handling

> Still has to be documented