{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Basic Tutorial\n",
    "\n",
    "In this tutorial you will learn the basics of `aiida-phonopy`. The core of the package is the Data Types wrapping the classes of Phonopy to generate structures in AiiDA, connecting them in the graph. \n",
    "\n",
    "We can divide the main workflow of Phonopy in mainly two phases:\n",
    "\n",
    "* __Pre-processing__: generating the (supercell) structures with displacements on top of which computing forces (for frozen phonons) \n",
    "* __Post-process__: collecting such data, ideally in a compact way, and use it for extracting phonon-related properties.\n",
    "\n",
    "In this tutorial we will make use of the silicon structure to give you an overall understanding of the usage of the package.\n",
    "If you are interested in more advanced features, please have a look at the [next tutorial](./intermidiate.ipynb) or to the [how tos](../howto/index.rst).\n",
    "\n",
    "Let's get started!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Generating supercell structures\n",
    "\n",
    "In a frozen phonon calculation, you need to first define the structures with displacements\n",
    "on top of which computing the forces.\n",
    "Here, you will learn how to do that in AiiDA, and how to obtain the displaced structures\n",
    "as {py:class}`~aiida.orm.StructureData` with full provenance.\n",
    "\n",
    "```{admonition} Exercise\n",
    "We will use the silicon structure throughout the tutorials, but note this can be easily\n",
    "substituted with any structure of your interest.\n",
    "```\n",
    "\n",
    "First, import the required classes and functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from local_module import load_temp_profile\n",
    "from aiida.plugins import DataFactory\n",
    "\n",
    "# If you download this file, you can run it with your own profile.\n",
    "# Put these lines instead:\n",
    "# from aiida import load_profile\n",
    "# load_profile()\n",
    "load_temp_profile(\n",
    "    name=\"basic-tutorial\",\n",
    "    add_computer=True,\n",
    "    add_phonopy_code=True,\n",
    ")\n",
    "\n",
    "\n",
    "StructureData = DataFactory(\"core.structure\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the silicon structure using the ASE module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a silicon cubic crystal\n",
    "a = 2.716\n",
    "cell = [[0,a,a],[a,0,a],[a,a,0]]\n",
    "\n",
    "structure = StructureData(cell=cell)\n",
    "structure.append_atom(position=(a,a,a), symbols=\"Si\")\n",
    "structure.append_atom(position=(1.5*a,1.5*a,1.5*a), symbols=\"Si\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now load the structure in the {py:class}`~aiida_phonopy.data.PreProcessData`,\n",
    "used to store and specify frozen phonon *preprocess information*, such as the supercell\n",
    "matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "PreProcessData = DataFactory(\"phonopy.preprocess\")\n",
    "\n",
    "supercell_matrix = [2,2,2] # similar to a q point mesh in DFPT approaches\n",
    "preprocess_data =  PreProcessData(structure=structure, supercell_matrix=supercell_matrix)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If not specified, the ``PreProcessData`` will automatically set other needed variables, such as the *primitive matrix*.\n",
    "\n",
    "```{note}\n",
    "To access this data, try to use the tab completion after typing **preprocess_data**. in the shell to navigate the\n",
    "stored data: can you find the defined supercell matrix? And the primitive matrix?\n",
    "```\n",
    "\n",
    "The structure that we set can be get using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0, 2.716, 2.716], [2.716, 0.0, 2.716], [2.716, 2.716, 0.0]]\n"
     ]
    }
   ],
   "source": [
    "unitcell = preprocess_data.get_unitcell()\n",
    "print(unitcell.cell)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{admonition} Exercise\n",
    "Can you tell it is the same structure we set?\n",
    "```\n",
    "\n",
    "As we specified the ``supercell_matrix``, the ``preprocess_data`` set a supercell\n",
    "with that dimensions in respect to the input structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.0, 5.432, 5.432], [5.432, 0.0, 5.432], [5.432, 5.432, 0.0]]\n"
     ]
    }
   ],
   "source": [
    "supercell = preprocess_data.get_supercell()\n",
    "print(supercell.cell)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{admonition} Question\n",
    "Has the ``supercell.cell`` the expected values?\n",
    "```\n",
    "\n",
    "Finally, as you have probably understood, the *supercells with displacements*,\n",
    "needed for frozen phonons, are easily accessed via:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supercell_1': <StructureData: uuid: b47b4a4f-3168-483b-b19b-d704a66b3278 (unstored)>}\n"
     ]
    }
   ],
   "source": [
    "supercells = preprocess_data.get_supercells_with_displacements()\n",
    "print(supercells)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method returns a dictionary with keys to identify the different ``StructureData``.\n",
    "\n",
    "```{admonition} Exercise\n",
    "How many structures there are? Can you explain why that number?\n",
    "```\n",
    "\n",
    "```{important}\n",
    "These keys have a one-to-one correspondence with the displacement dataset,\n",
    "also stored in the ``PreProcessData``. Do **never** modify them, as they will\n",
    "be needed later to collect correctly the forces associated to each of them.\n",
    "```\n",
    "\n",
    "To obtain phonon information, the next step is to compute the forces on each of these ``StructureData``,\n",
    "e.g. using the [aiida-quantumespresso](https://aiida-quantumespresso.readthedocs.io/en/latest/)\n",
    "{py:class}`~aiida_quantumespresso.workflows.pw.base.PwBaseWorkChain`.\n",
    "\n",
    "Before ending this section, *have you noticed something about all the* ``StructureData``?\n",
    "\n",
    "**They are all not stored!** This means they are not connected with a link in the graph to the\n",
    "``PreProcessData``. To do so, you can use the `calcfunction` utilities we provide within the\n",
    "``PreProcessData``, and access the very same methods. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "05/10/2023 09:19:39 AM <2277112> aiida.engine.processes.functions: [WARNING] function `generate_preprocess_data` has invalid type hints: unsupported operand type(s) for |: 'AbstractNodeMeta' and 'NoneType'\n",
      "05/10/2023 09:19:39 AM <2277112> aiida.engine.processes.functions: [WARNING] function `generate_phonopy_data` has invalid type hints: unsupported operand type(s) for |: 'AbstractNodeMeta' and 'NoneType'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supercell_1': <StructureData: uuid: 80d2a02f-bd30-40ef-9cd7-dd8791113e6f (pk: 4)>}\n"
     ]
    }
   ],
   "source": [
    "supercells = preprocess_data.calcfunctions.get_supercells_with_displacements()\n",
    "print(supercells)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{admonition} Question\n",
    "Are they now stored? And the ``preprocess_data``?\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Collecting the forces for post-processing\n",
    "\n",
    "Once the structures with displacements are defined, before being able to calculate phonon properties,\n",
    "we need to compute the **forces** on each ``StructureData``.\n",
    "\n",
    "Imagine we have already computed these forces via the [aiida-quantumespresso](https://aiida-quantumespresso.readthedocs.io/en/latest/)\n",
    "{py:class}`~aiida_quantumespresso.workflows.pw.base.PwBaseWorkChain`. The result would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Raw array data computed using QuantumESPRESSO and PBEsol\n",
    "# Units of forces in eV/Angstrom\n",
    "# Should contain all forces of all supercells with displacements\n",
    "dict_of_forces = {\n",
    "    \"forces_1\": # Forces of Supercell 1 (with displacement)\n",
    "    [\n",
    "        [-1.54754697e-03, -9.61674843e-02, -9.61674843e-02], # force on atom 1\n",
    "        [ 2.31399281e-06,  6.38482038e-03,  6.38482038e-03], # force on atom 2\n",
    "        [ 3.43602221e-03, -6.21769868e-03,  2.87834994e-03], # force on atom 3\n",
    "        [-3.48847271e-03,  2.97502342e-03, -6.20510027e-03], # force on atom 4\n",
    "        [ 3.43602221e-03,  2.87834994e-03, -6.21769868e-03], # force on atom 5\n",
    "        [-3.48847271e-03, -6.20510027e-03,  2.97502342e-03], # force on atom 6\n",
    "        [ 2.93105756e-05, -5.08564197e-04, -5.08564197e-04], # force on atom 7\n",
    "        [-3.85665468e-05,  9.59278574e-04,  9.59278574e-04], # force on atom 8\n",
    "        [ 3.38177193e-02,  4.19431765e-02,  4.19431765e-02], # force on atom 9\n",
    "        [-3.22511462e-02,  4.08964805e-02,  4.08964805e-02], # force on atom 10\n",
    "        [ 1.00015911e-04,  8.34940027e-03,  8.39439458e-03], # force on atom 11\n",
    "        [-6.47917986e-05, -1.89901677e-03, -1.89284612e-03], # force on atom 12\n",
    "        [ 1.00015911e-04,  8.39439458e-03,  8.34940027e-03], # force on atom 13\n",
    "        [-6.47917986e-05, -1.89284612e-03, -1.89901677e-03], # force on atom 14\n",
    "        [-1.98951959e-03, -1.20841847e-05, -1.20841847e-05], # force on atom 15\n",
    "        [ 2.01163108e-03,  1.22127398e-04,  1.22127398e-04], # force on atom 16\n",
    "    ]\n",
    "# if we had other forces we would continue\n",
    "#   \"forces_2\": [...],\n",
    "#   \"forces_3\": [...], \n",
    "#   ...\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For the case of Si, only the forces of one supercell with displacements are needed (check again above).\n",
    "We now join these forces together with the ``PreProcessData`` obtained before in a new data meant to store together this information, called {py:class}`~aiida_phonopy.data.phonopy.PhonopyData`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "PhonopyData = DataFactory(\"phonopy.phonopy\")\n",
    "\n",
    "phonopy_data =  PhonopyData(preprocess_data=preprocess_data)\n",
    "phonopy_data.set_forces(dict_of_forces=dict_of_forces)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each key must be of the shape ``forces_{i}``, ``{i}`` referring to the number of the supercell provided in the dictionary of ``supercells_with_displacements``.\n",
    "\n",
    "If we want to keep provenance, linking forces stored as ``ArrayData`` computed using a ``CalcJob`` or ``WorkChain`` input, we can use the dedicated ``calcfunction`` from the `preprocess_data` stored before.\n",
    "\n",
    "```{important} Convention\n",
    "Each ArrayData must contain the forces within the arrayname **forces**!\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from aiida.orm import ArrayData\n",
    "\n",
    "# The ArrayData/TrajectoryData of an AiiDA plugin, e.g. aiida-quantumespresso\n",
    "forces_1 = ArrayData()\n",
    "forces_1.set_array(\"forces\", np.array(dict_of_forces['forces_1']) )\n",
    "dict_of_forces = {'forces_1': forces_1}\n",
    "\n",
    "phonopy_data = preprocess_data.calcfunctions.generate_phonopy_data(**dict_of_forces)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Running `phonopy` for post-processing\n",
    "\n",
    "```{important}\n",
    "If you haven't done it yet, configure a ``Code`` for the ``phonopy`` executable. See [here](../installation/index/installation-setup) for more details.\n",
    "```\n",
    "\n",
    "It is finally time to post-process our produced data and get some phonon properties! \n",
    "To do so, we can now use the {py:class}`~aiida_phonopy.calculations.phonopy.PhonopyCalculation`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aiida.plugins import CalculationFactory\n",
    "\n",
    "PhonopyCalculation = CalculationFactory(\"phonopy.phonopy\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As usual for calculations in AiiDA, we can get the builder to understand which inputs are needed.\n",
    "\n",
    "```{note}\n",
    "For a full list of inputs, you can have a look at the [topic section](../topics/calculations/phonopy.rst) for {py:class}`~aiida_phonopy.calculations.phonopy.PhonopyCalculation`.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "builder = PhonopyCalculation.get_builder()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the inputs:\n",
    "\n",
    "* ``code``: the ``Code`` which will run the phonopy post-processing\n",
    "* ``phonopy_data``: the Data node containing the information regarding structure, supercell, displacements and forces\n",
    "* ``parameters``: the dictionary with key/pair tags of properties to compute (for a full list, refer to the [Phonopy Documentation](https://phonopy.github.io/phonopy/setting-tags.html))\n",
    "\n",
    "In the following, we will ask for an automatic **phonon band structure** calculaiton."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aiida.orm import load_code, Dict\n",
    "\n",
    "builder.code = load_code(\"phonopy@local_direct\") # WARNING! You may redefine this\n",
    "builder.phonopy_data = phonopy_data\n",
    "builder.parameters = Dict({\"band\":\"auto\"})"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now submit the calculation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aiida.engine import run_get_node\n",
    "\n",
    "results, node = run_get_node(builder)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, the same can be achieved via the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = {\n",
    "    \"code\": load_code(\"phonopy@local_direct\"),\n",
    "    \"phonopy_data\": phonopy_data,\n",
    "    \"parameters\": Dict({\"band\":\"auto\"})\n",
    "}\n",
    "\n",
    "# from aiida.engine import submit\n",
    "# node = submit(PhonopyCalculation, **inputs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'output_parameters': <Dict: uuid: 7c0291dd-86d5-4141-8fbf-ff4bee724d99 (pk: 12)>,\n",
       " 'phonon_bands': <BandsData: uuid: 517dfb4b-eb3d-46bb-bb44-8831c5248b98 (pk: 13)>,\n",
       " 'remote_folder': <RemoteData: uuid: 83632056-3714-449e-9b89-2195767a9806 (pk: 10)>,\n",
       " 'retrieved': <FolderData: uuid: fb9bf37e-37ff-4f5e-8c26-4dc28ac32e8c (pk: 11)>}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now explore the outputs! To do so, just type `calc.outputs.` and then press Tab for exploring the outputs!\n",
    "\n",
    "```{admonition} Question\n",
    "Is there what you expect? Any ``BandsData``?\n",
    "```\n",
    "\n",
    "We can now use the ``phonon_bands`` to plot them directly on screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "node.outputs.phonon_bands.show_mpl()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.8.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}