yambo/3_1_YamboWorkflow_G0W0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c971091a",
   "metadata": {},
   "source": [
    "# YamboWorkflow: a full DFT+MBPT flow\n",
    "\n",
    "The `YamboWorkflow`  is the core workchain of the plugin that takes care of performing all the steps needed in a typical Yambo simulation,\n",
    "from preliminary self-consistent (SCF) and non-self-consistent (NSCF) DFT calculations to the proper GW (BSE) calculations and related post-processing.\n",
    "The workflow ensures a robust interoperability between DFT and MBPT codes (QuantumESPRESSO and Yambo, respectively), and links subsequent calculations, \n",
    "interfacing the data automatically. \n",
    "In practice, YamboWorkflow encodes a dynamic execution according to the instructions provided in input. \n",
    "This implies performing all the intermediate steps needed for a specific calculations \n",
    "without the need of instructing them explicitly or, on the contrary, to skip some of the intermediate steps for which parent calculations are available, fully \n",
    "exploiting the YamboWorkflow provenance information. It uses the PwBaseWorkchain from `aiida-quantumespresso`\n",
    "as a subworkflow to perform the first DFT part if required, and the `YamboRestart` for the GW part. A smart logic is considered to understand what \n",
    "process has to be done to achieve success. If the previous calculation is not `finished_ok`, the workflow will exit in a failed status: we rely on the fact that \n",
    "the success of a calculation is guaranteed by the BaseRestartWorkchain used at the lower level of the plugin. \n",
    "\n",
    "NB: it is also possible to run BSE@GW (or just DFT), as you will see in a following dedicated tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "68def2e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from aiida import orm, load_profile\n",
    "load_profile()\n",
    "\n",
    "from aiida.plugins import WorkflowFactory\n",
    "from aiida.orm import QueryBuilder\n",
    "from aiida.engine import submit\n",
    "\n",
    "from aiida_quantumespresso.common.types import ElectronicType\n",
    "\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5da362de",
   "metadata": {},
   "source": [
    "## Providing the minimal inputs needed for protocols\n",
    "\n",
    "We have to provide minimal inputs for the creation of the builder instance, namely:\n",
    "- codes;\n",
    "- structure;\n",
    "\n",
    "Providing a parent calculation as input, the already performed steps are skipped, in order to avoid waste of human and computational time.\n",
    "If no parent is passed to the builder, also DFT inputs are created within the protocols as provided in the `PwBaseWorkChain`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c52a8ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "qb = QueryBuilder()\n",
    "qb.append(orm.Group, filters={'label': 'Silicon/bulk'}, tag='group')\n",
    "qb.append(orm.StructureData, with_group='group')\n",
    "\n",
    "loaded_structure_id = qb.all()[0][0].pk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6c66fa32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read YAML file\n",
    "with open(\"../configuration/codes_localhost.yaml\", 'r') as stream:\n",
    "    codes = yaml.safe_load(stream)\n",
    "    \n",
    "with open(\"../configuration/resources_localhost.yaml\", 'r') as stream:\n",
    "    resources = yaml.safe_load(stream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a94bf0e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "options = {\n",
    "    'pseudo_family':\"PseudoDojo/0.4/PBE/SR/standard/upf\",\n",
    "    'protocol':'fast',\n",
    "    #'parent_id':274, #not necessary to set; if you want it, take ytheour previously nscf id (pk) to skip the DFT part.\n",
    "    'structure_id':loaded_structure_id,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "85a9c1fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "options.update(codes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "33d261f6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summary of the main inputs:\n",
      "BndsRnXp = 150\n",
      "GbndRnge = 150\n",
      "NGsBlkXp = 2 Ry\n",
      "FFTGvecs = 9 Ry\n",
      "\n",
      "\n",
      "kpoint mesh for nscf: [6, 6, 6]\n"
     ]
    }
   ],
   "source": [
    "YamboWorkflow = WorkflowFactory('yambo.yambo.yambowf')\n",
    "\n",
    "builder = YamboWorkflow.get_builder_from_protocol(\n",
    "    pw_code = options['pwcode_id'],\n",
    "    preprocessing_code = options['yamboprecode_id'],\n",
    "    code = options['yambocode_id'],\n",
    "    protocol=options['protocol'],\n",
    "    protocol_qe=options['protocol'],\n",
    "    structure= orm.load_node(options['structure_id']),\n",
    "    overrides={},\n",
    "    pseudo_family= options['pseudo_family'],\n",
    "    #parent_folder=orm.load_node(options['parent_id']).outputs.remote_folder,\n",
    "    electronic_type=ElectronicType.INSULATOR, #default is METAL: in that case, smearing is used\n",
    "    calc_type='gw', #or 'bse'; default is 'gw'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "60f67f0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fast': {'description': 'Under converged for most materials, but fast'},\n",
       " 'moderate': {'description': 'Meta converged for most materials, higher computational cost than fast'},\n",
       " 'precise': {'description': 'Converged for most materials, higher computational cost than moderate'}}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#You can also try different protocols:\n",
    "    \n",
    "YamboWorkflow.get_available_protocols()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e65850e",
   "metadata": {},
   "source": [
    "Now, if you inspect the prepopulated inputs, you can see the default values respecting the imposed protocol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b526b07c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'CONTROL': {'calculation': 'nscf',\n",
       "  'forc_conv_thr': 0.001,\n",
       "  'tprnfor': True,\n",
       "  'tstress': True,\n",
       "  'etot_conv_thr': 0.0002},\n",
       " 'SYSTEM': {'nosym': False,\n",
       "  'occupations': 'fixed',\n",
       "  'ecutwfc': 30.0,\n",
       "  'ecutrho': 240.0,\n",
       "  'force_symmorphic': True,\n",
       "  'nbnd': 150},\n",
       " 'ELECTRONS': {'electron_maxstep': 80, 'mixing_beta': 0.4, 'conv_thr': 8e-10}}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.nscf.pw.parameters.get_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0bae1faf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'arguments': ['dipoles', 'ppa', 'HF_and_locXC', 'gw0'],\n",
       " 'variables': {'Chimod': 'hartree',\n",
       "  'DysSolver': 'n',\n",
       "  'GTermKind': 'BG',\n",
       "  'X_and_IO_nCPU_LinAlg_INV': [1, ''],\n",
       "  'NGsBlkXp': [2, 'Ry'],\n",
       "  'FFTGvecs': [9, 'Ry'],\n",
       "  'BndsRnXp': [[1, 150], ''],\n",
       "  'GbndRnge': [[1, 150], ''],\n",
       "  'QPkrange': [[[1, 1, 32, 32]], '']}}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.yres.yambo.parameters.get_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a7f7db",
   "metadata": {},
   "source": [
    "We then provide the computational resources:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "192fd6b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "builder.scf.pw.metadata.options = resources\n",
    "\n",
    "builder.nscf.pw.metadata.options = builder.scf.pw.metadata.options\n",
    "builder.yres.yambo.metadata.options = builder.scf.pw.metadata.options"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb984fa",
   "metadata": {},
   "source": [
    "### Overrides\n",
    "\n",
    "As in the previous examples (see e.g. then  `YamboRestart` notebook), it is possible to modify the default inputs also during the builder creation phase, so not a posteriori. This can be done by using overrides:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "09f5f8c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "overrides_scf = {\n",
    "        'pseudo_family': \"PseudoDojo/0.4/PBE/SR/standard/upf\", \n",
    "        'pw':{\n",
    "        'metadata':{\"options\":resources},\n",
    "        },\n",
    "    }\n",
    "\n",
    "overrides_nscf = {\n",
    "        'pseudo_family': \"PseudoDojo/0.4/PBE/SR/standard/upf\", \n",
    "        'pw': {\n",
    "            'parameters':{\n",
    "                'CONTROL':{}, #not needed if you don't override something\n",
    "                'SYSTEM':{},\n",
    "                'ELECTRONS':{'diagonalization':'david'},\n",
    "            },\n",
    "             'metadata':{\"options\":resources},\n",
    "    },\n",
    "}\n",
    "\n",
    "overrides_yambo = {\n",
    "        \"yambo\": {\n",
    "            \"parameters\": {\n",
    "                \"arguments\": [\n",
    "                    \"rim_cut\",\n",
    "                ],\n",
    "                \"variables\": {\n",
    "                    \"NGsBlkXp\": [4, \"Ry\"],\n",
    "                    \"FFTGvecs\": [24, \"Ry\"],\n",
    "                },\n",
    "            },\n",
    "        'metadata':{\"options\":resources},\n",
    "        },\n",
    "    \n",
    "}\n",
    "\n",
    "overrides = {\n",
    "    'yres': overrides_yambo,\n",
    "    'nscf': overrides_nscf,\n",
    "    'scf': overrides_scf\n",
    "    \n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6db71a1",
   "metadata": {},
   "source": [
    "So, let's create a new builder instance with also the `overrides` information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "15f63ee7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Summary of the main inputs:\n",
      "BndsRnXp = 150\n",
      "GbndRnge = 150\n",
      "NGsBlkXp = 4 Ry\n",
      "FFTGvecs = 24 Ry\n",
      "\n",
      "\n",
      "kpoint mesh for nscf: [6, 6, 6]\n"
     ]
    }
   ],
   "source": [
    "builder = YamboWorkflow.get_builder_from_protocol(\n",
    "    pw_code = options['pwcode_id'],\n",
    "    preprocessing_code = options['yamboprecode_id'],\n",
    "    code = options['yambocode_id'],\n",
    "    protocol=options['protocol'],\n",
    "    protocol_qe=options['protocol'],\n",
    "    structure= orm.load_node(options['structure_id']),\n",
    "    overrides=overrides,\n",
    "    #parent_folder=load_node(options['parent_id']).outputs.remote_folder,\n",
    "    electronic_type=ElectronicType.INSULATOR, #default is METAL: smearing is used\n",
    "    calc_type='gw', #or 'bse'; default is 'gw'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e8f7428b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'CONTROL': {'calculation': 'nscf',\n",
       "  'forc_conv_thr': 0.001,\n",
       "  'tprnfor': True,\n",
       "  'tstress': True,\n",
       "  'etot_conv_thr': 0.0002},\n",
       " 'SYSTEM': {'nosym': False,\n",
       "  'occupations': 'fixed',\n",
       "  'ecutwfc': 36.0,\n",
       "  'ecutrho': 144.0,\n",
       "  'force_symmorphic': True,\n",
       "  'nbnd': 150},\n",
       " 'ELECTRONS': {'electron_maxstep': 80,\n",
       "  'mixing_beta': 0.4,\n",
       "  'diagonalization': 'david',\n",
       "  'conv_thr': 8e-10}}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.nscf.pw.parameters.get_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "229a75be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'david'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "builder.nscf.pw.parameters.get_dict()['ELECTRONS']['diagonalization']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a99fef9",
   "metadata": {},
   "source": [
    "Input nesting: as you may notice, here the builder has new attributes, referring to scf, nscf and yambo parts: this means that we are actually providing the inputs for \n",
    "respectively two PwBaseWorkchains and YamboRestart. \n",
    "The only 'strict' YamboWorkflow input is now the ``parent_folder``."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7646f77",
   "metadata": {},
   "source": [
    "### Requesting the YamboWorkflow to compute specific quantities: the minimum band gap and the direct band gap at Gamma\n",
    "\n",
    "Within `YamboWorkflow`, it is possible to obtain the band gap of a material without explicitely providing the corresponding k-point and band set of indices. The workflow contains the logic to inspect DFT band structure, as computed in the nscf step, and determine the k-points and electronic band coordinates.\n",
    "In this way, the exact quasiparticle levels can be computed without additional human intervention. Of course this logic will suffer effects like the change of the reciprocal space positions of the band gap, after GW correction. This requires a further analysis of the GW band structure. \n",
    "\n",
    "Here below we see how to set the `additional_parsing` attribute of the builder. This consists in an AiiDA List containing strings, each of them\n",
    "representing the desired quantity. In this case, we want to compute the band gap at Gamma and the minimal gap, respectively \"gap_GG\" and \"gap_\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c0a81b69",
   "metadata": {},
   "outputs": [],
   "source": [
    "builder.additional_parsing = orm.List(list=['gap_GG','gap_'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a52d8312",
   "metadata": {},
   "source": [
    "It is possible also to ask for other high-symmetry points, e.g. M, K. However, if the points are not contained in our mesh, their quasiparticle correction is skipped (it cannot be computed). \n",
    "Indirect gaps can be computed, providing a string of the type \"gap_AB\", where `A` is the k-point for the top valence band, and `B` is the k-points of the bottom conduction bands. For example, the indirect gap G->M \n",
    "can be computed providing the \"gap_GM\" string in the `additional_parsing` List.\n",
    "\n",
    "Other examples are:\n",
    "```bash\n",
    "   builder.additional_parsing = List(list=['gap_','gap_GG','homo','lumo']) #GW\n",
    "   builder.additional_parsing = List(list=['lowest_exciton','brightest_exciton']) #BSE\n",
    "```\n",
    "\n",
    "Finally, also single particle levels can be computed for the last valence and first conduction bands. What we need to provide is the string \"homo_K\" or \"lumo_K\", respectively. `K` is the desired high-symmetry k-point.\n",
    "To explicitly compute the top valence and the bottom conduction GW energies, just provide \"homo\" and \"lumo\".\n",
    "\n",
    "The requested quantity is then stored in a human-readable output Dict called `output_ywfl_parameters`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fa45b07",
   "metadata": {},
   "source": [
    "### Submission phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9e47d544",
   "metadata": {},
   "outputs": [],
   "source": [
    "run = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f1aed687",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/max/.conda/envs/aiida/lib/python3.9/site-packages/aiida_quantumespresso/calculations/pw.py:211: UserWarning: `parent_folder` not provided for `nscf` calculation. For work chains wrapping this calculation, you can disable this warning by excluding the `parent_folder` when exposing the inputs of the `PwCalculation`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uuid: 0211849f-8973-446a-81fe-6248ef08b3d5 (pk: 488) (aiida.workflows:yambo.yambo.yambowf)\n"
     ]
    }
   ],
   "source": [
    "if run:\n",
    "    print('run is already running -> {}'.format(run.pk))\n",
    "    print('sure that you want to run again?, if so, copy the else instruction in the cell below and run!')\n",
    "else:\n",
    "    run = submit(builder)\n",
    "\n",
    "print(run)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d0ccb899",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[22m2024-02-19 15:15:26 [28 | REPORT]: [488|YamboWorkflow|start_workflow]: no previous pw calculation found, we will start from scratch\n",
      "2024-02-19 15:15:26 [29 | REPORT]: [488|YamboWorkflow|start_workflow]:  workflow initilization step completed.\n",
      "2024-02-19 15:15:27 [30 | REPORT]: [488|YamboWorkflow|can_continue]: the workflow continues with a scf calculation\n",
      "2024-02-19 15:15:27 [31 | REPORT]: [488|YamboWorkflow|perform_next]: performing a scf calculation\n",
      "2024-02-19 15:15:28 [32 | REPORT]:   [489|PwBaseWorkChain|run_process]: launching PwCalculation<494> iteration #1\n",
      "2024-02-19 15:15:33 [33 | REPORT]:   [489|PwBaseWorkChain|results]: work chain completed after 1 iterations\n",
      "2024-02-19 15:15:33 [34 | REPORT]:   [489|PwBaseWorkChain|on_terminated]: remote folders will not be cleaned\n",
      "2024-02-19 15:15:33 [35 | REPORT]: [488|YamboWorkflow|can_continue]: the workflow continues with a nscf calculation\n",
      "2024-02-19 15:15:33 [36 | REPORT]: [488|YamboWorkflow|perform_next]: performing a nscf calculation\n",
      "2024-02-19 15:15:34 [37 | REPORT]:   [500|PwBaseWorkChain|run_process]: launching PwCalculation<503> iteration #1\n",
      "2024-02-19 15:16:06 [38 | REPORT]:   [500|PwBaseWorkChain|results]: work chain completed after 1 iterations\n",
      "2024-02-19 15:16:07 [39 | REPORT]:   [500|PwBaseWorkChain|on_terminated]: remote folders will not be cleaned\n",
      "2024-02-19 15:16:07 [40 | REPORT]: [488|YamboWorkflow|can_continue]: the workflow continues with a yambo calculation\n",
      "2024-02-19 15:16:07 [41 | REPORT]: [488|YamboWorkflow|perform_next]: performing a yambo calculation\n",
      "2024-02-19 15:16:07 [42 | REPORT]: [488|YamboWorkflow|perform_next]: updating yambo parameters to parse more results\n",
      "2024-02-19 15:16:07 [43 | REPORT]: [488|YamboWorkflow|perform_next]: {'dft_predicted': 'semiconductor/insulator', 'valence': 4, 'conduction': 5, 'number_of_kpoints': 16, 'nscf_gap_eV': 0.665, 'homo_k': 1, 'lumo_k': 13, 'gap_type': 'indirect', 'gap_': [[1, 1, 4, 4], [13, 13, 5, 5]], 'soc': False, 'magnetic_calculation': False, 'gap_GG': [[1, 1, 4, 4], [1, 1, 5, 5]]}\n",
      "2024-02-19 15:16:09 [44 | REPORT]:   [510|YamboRestart|run_process]: launching YamboCalculation<511> iteration #1\n",
      "2024-02-19 15:17:18 [45 | REPORT]:   [510|YamboRestart|results]: work chain completed after 1 iterations\n",
      "2024-02-19 15:17:18 [46 | REPORT]:   [510|YamboRestart|on_terminated]: remote folders will not be cleaned\n",
      "2024-02-19 15:17:18 [47 | REPORT]: [488|YamboWorkflow|can_continue]: workflow is finished\n",
      "2024-02-19 15:17:18 [48 | REPORT]: [488|YamboWorkflow|post_processing_needed]: no post processing needed\n",
      "2024-02-19 15:17:19 [49 | REPORT]: [488|YamboWorkflow|report_wf]: PARSED: {'gap_GG': 3.061329049271345, 'homo_G': -0.30465849325060845, 'lumo_G': 2.7566705560207367, 'gap_GG_dft': 2.5552411541998388, 'homo_G_dft': 0.0, 'lumo_G_dft': 2.5552411541998388, 'gap_': 1.0573099312007428, 'homo': -0.30465849325060845, 'lumo': 0.7526514379501343, 'gap_dft': 0.6647308934748173, 'homo_dft': 0.0, 'lumo_dft': 0.6647308934748173}\n",
      "2024-02-19 15:17:19 [50 | REPORT]: [488|YamboWorkflow|report_wf]: workflow completed successfully\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!verdi process report {run.pk}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7a6c1de",
   "metadata": {},
   "source": [
    "### Inspecting the outputs\n",
    "\n",
    "Suppose that your calculation finished successfully, then you can access the outputs via the output method of the run instance. All the outputs of YamboRestart and YamboCalculation are inherited here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c4bbc54e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run.is_finished_ok"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "911f5bc2",
   "metadata": {},
   "source": [
    "We can then inspect the outputs, in particular the additional parsed information that we requested. \n",
    "These are collected in the `output_ywfl_parameters` output node, which is an AiiDA dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ccfe29be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gap_': 1.0573099312007,\n",
       " 'homo': -0.30465849325061,\n",
       " 'lumo': 0.75265143795013,\n",
       " 'gap_GG': 3.0613290492713,\n",
       " 'homo_G': -0.30465849325061,\n",
       " 'lumo_G': 2.7566705560207,\n",
       " 'gap_dft': 0.66473089347482,\n",
       " 'homo_dft': 0.0,\n",
       " 'lumo_dft': 0.66473089347482,\n",
       " 'gap_GG_dft': 2.5552411541998,\n",
       " 'homo_G_dft': 0.0,\n",
       " 'lumo_G_dft': 2.5552411541998}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run.outputs.output_ywfl_parameters.get_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f644ad25",
   "metadata": {},
   "source": [
    "Moreover, the information extracted from the nscf step are stored in the `nscf_mapping` output node:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ed6fc55e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'soc': False,\n",
       " 'gap_': [[1, 1, 4, 4], [13, 13, 5, 5]],\n",
       " 'gap_GG': [[1, 1, 4, 4], [1, 1, 5, 5]],\n",
       " 'homo_k': 1,\n",
       " 'lumo_k': 13,\n",
       " 'valence': 4,\n",
       " 'gap_type': 'indirect',\n",
       " 'conduction': 5,\n",
       " 'nscf_gap_eV': 0.665,\n",
       " 'dft_predicted': 'semiconductor/insulator',\n",
       " 'number_of_kpoints': 16,\n",
       " 'magnetic_calculation': False}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run.outputs.nscf_mapping.get_dict()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}