examples/tutorials/descriptors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Descriptors calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dLs_a7wLt98_"
   },
   "source": [
    "To run calculate descriptors using aiida-mlip you need to define some inputs as AiiDA data types, to then pass them to the calculation.\n",
    "\n",
    "First of all we need a structure on which to perform the calculations. It will be a NaCl structure that we define using ASE, or alternatively one can choose one of the structures in the folder `Structures`.\n",
    "\n",
    "The input structure in aiida-mlip needs to be saved as a StructureData type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from aiida import load_profile\n",
    "\n",
    "load_profile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NmNkuWExt8RE"
   },
   "outputs": [],
   "source": [
    "from aiida.orm import StructureData\n",
    "from ase.build import bulk\n",
    "from ase.io import read\n",
    "\n",
    "# structure = StructureData(ase=read(\"Structures/qmof-ffeef76.cif\"))\n",
    "structure = StructureData(ase=bulk(\"NaCl\", \"rocksalt\", 5.63))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YxOTQEg9uGnN"
   },
   "source": [
    "Then we need to choose a model and architecture to be used for the calculation and save it as ModelData type, a specific data type of this plugin.\n",
    "In this example we use MACE with a model that we download from this URL: \"https://github.com/stfc/janus-core/raw/main/tests/models/mace_mp_small.model\", and we save the file in the cache folder (default=\"~/.cache/mlips/\"):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3iGSzzNithOk"
   },
   "outputs": [],
   "source": [
    "from aiida_mlip.data.model import ModelData\n",
    "\n",
    "uri = \"https://github.com/stfc/janus-core/raw/main/tests/models/mace_mp_small.model\"\n",
    "# model = ModelData.from_uri(uri, architecture=\"mace_mp\", cache_dir=\"mlips\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Cf28b-C1uM_I"
   },
   "source": [
    "If we already have the model saved in some folder we can save it as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sqoVIB2guSKM"
   },
   "outputs": [],
   "source": [
    "from aiida_mlip.data.model import ModelData\n",
    "\n",
    "model = ModelData.from_local(\"/home/ek/.cache/mace/46jrkm3v\", architecture=\"mace\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xvEMrU5zuVn_"
   },
   "source": [
    "Another parameter that we need to define as AiiDA type is the code. Assuming the code is saved as `janus` in the `localhost` computer, the code info that are needed can be loaded as follow:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mH5E3MtPtyj-"
   },
   "outputs": [],
   "source": [
    "from aiida.orm import load_code\n",
    "\n",
    "code = load_code(\"janus@localhost\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u-nJa_viuZMv"
   },
   "source": [
    "The other inputs can be set up as AiiDA Str. There is a default for every input except the structure and code. This is a list of possible inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_XkQgKPMtyhf"
   },
   "outputs": [],
   "source": [
    "from aiida.orm import Bool, Str\n",
    "\n",
    "inputs = {\n",
    "    \"code\": code,\n",
    "    \"model\": model,\n",
    "    \"struct\": structure,\n",
    "    \"arch\": Str(model.architecture),\n",
    "    \"precision\": Str(\"float64\"),\n",
    "    \"device\": Str(\"cpu\"),\n",
    "    \"metadata\": {\"options\": {\"resources\": {\"num_machines\": 1}}},\n",
    "    \"invariants_only\": Bool(True),\n",
    "    \"calc_per_atom\": Bool(True),\n",
    "    \"calc_per_element\": Bool(True),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RCPc7-Z5uhoK"
   },
   "source": [
    "It's worth noting that the architecture is already defined within the model, accessible through the architecture property in the ModelData. Even if not explicitly provided as input, it will be automatically retrieved from the model.\n",
    "\n",
    "The calculation must be set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XOaSjxT8tyek"
   },
   "outputs": [],
   "source": [
    "from aiida.plugins import CalculationFactory\n",
    "\n",
    "DescriptorsCalc = CalculationFactory(\"mlip.descriptors\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BhWwGwm2uvYR"
   },
   "source": [
    "In this case, since we are running a single point calculation the entry point for the calculation is `mlip.sp`.\n",
    "Finally, run the calculation:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "agibHmT-tyU2"
   },
   "outputs": [],
   "source": [
    "from aiida.engine import run_get_node\n",
    "\n",
    "result, node = run_get_node(DescriptorsCalc, inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OSt6cQMeu5w9"
   },
   "source": [
    "`result` is a dictionary of the available results obtained from the calculation, while node contains the infor on the node where the calculation is run:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZwVf9a-Fu5aW"
   },
   "outputs": [],
   "source": [
    "print(result)\n",
    "print(node)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check if the calculation finished with errors. If everything worked the exit code should be 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if node.is_finished_ok:\n",
    "    print(f\"Caculation is finished without errors with exit status {node.exit_status}\")\n",
    "else:\n",
    "    print(f\"Some errors occurred with exit status {node.exit_status}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L5oMOnQPvID2"
   },
   "source": [
    "If more information are needed on specific outputs they can be called like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xyJnGWqlIQNT"
   },
   "outputs": [],
   "source": [
    "print(result[\"results_dict\"].get_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want the descriptor we can access it via the result or the node variable.\n",
    "(when this is run in the terminal the auto-completion should help, but the idea is that the results_dict is one of the outputs which contains the main info on the calculation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"Descriptor: {result['results_dict'].get_dict()['info']['mace_descriptor']}\")\n",
    "print(f\"Descriptor: {node.outputs.results_dict.get_dict()['info']['mace_descriptor']}\")\n",
    "print(f\"Cl Descriptor: {result['results_dict'].get_dict()['info']['mace_Cl_descriptor']}\")\n",
    "print(f\"Na Descriptor: {result['results_dict'].get_dict()['info']['mace_Na_descriptor']}\")\n",
    "print(f\"Descriptors: {result['results_dict'].get_dict()['mace_descriptors']}\")\n",
    "print(node.outputs.results_dict.get_dict()[\"cell\"][0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Through the command line we can see the processes that are run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! verdi process list -a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And see the results we are interested in. Substitute the number with the PK number of your calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! verdi calcjob res pk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also see the inputs and outputs of the calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! verdi node show pk  "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "private_outputs": true,
   "provenance": []
  },
  "kernelspec": {
   "display_name": "venv_aiida_11",
   "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.11.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}