{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Gaussian approximation potential (GAP) for  the Zundel cation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The present notebook is meant to give you an overview of the main ingredients that you need to build an interatomic potential with `librascal` and use it in connection with i-Pi (https://github.com/lab-cosmo/i-pi) to generate molecular dynamics (MD) trajectories of the system of interest. \n",
    "We will start from building a GAP model for Zundel cations ($H_5O_2+$), using a training set obtained via Bowman PES sampling, calculate its RMSE on a test set to check its performance and run a short NVT simulation at $\\text{T} = 250\\,\\text{K}$. \n",
    "\n",
    "The mathematical framework that we are going to use is the kernel-GAP fitting method, using both total energies and atomic forces as target properties. Basically the GAP-model total energy of a zundel molecule is computed using the following expression: \n",
    "\n",
    "$$\n",
    "                    E = E_0 + \\sum_i \\sum_{s=1}^M \\alpha_s K(\\bf{d_i} , \\bf{d_s} )                   \n",
    "$$\n",
    "\n",
    "where $E_0$ represents an energy baseline (given usually by the sum of atomic self-contributions), $\\bf{d_i}$ ($i = 1, \\dots, N_{atoms}$) are the set of (normalized SOAP) descriptors describing an environment centred around atom $i$, $\\bf{d_s}$ the set of descriptors corresponding to the environments of the sparse set (of size $M$) and K a kernel matrix that describes the similarity of two different atomic environments. In our application, the kernel is just the dot product, raised to some integer power $\\zeta$: \n",
    "\n",
    "$$\n",
    "        K(\\bf{d_i} , \\bf{d_s} ) \\propto \\left| \\bf{d_i} \\cdot \\bf{d_s} \\right|^{\\zeta}           \n",
    "$$\n",
    "\n",
    "Finally $\\alpha_s$ represents the weights of each sparse environment, to be determined using Kernel-Ridge Regression (KRR). For extensive details on the SOAP GAP-model fitting procedure and interesting physical applications, we invite the reader to refer to the book chapter [1].\n",
    "Details on the implementation in `librascal` are instead given in the companion publication [2].\n",
    "\n",
    "[1]: M. Ceriotti, M.J. Willatt, and G. Csányi, in Handbook of Materials Modeling (Springer International Publishing, Cham, 2018), pp. 1–27. https://doi.org/10.1007/978-3-319-42913-7_68-1\n",
    "\n",
    "[2]: F. Musil, M. Veit, A. Goscinski, G. Fraux, M.J. Willatt, M. Stricker, T. Junge, and M. Ceriotti, J. Chem. Phys. 154, 114109 (2021). https://doi.org/10.1063/5.0044689"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting started "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to be able to fit a potential with `librascal` (the model evaluator) and interface it with i-Pi (the MD engine) we first need to have both softwares available and correctly installed. For `librascal`, the following should suffice:\n",
    "```bash\n",
    "$ pip install git+https://github.com/lab-cosmo/librascal.git\n",
    "```\n",
    "\n",
    "and the same for i-PI:\n",
    "```bash\n",
    "$ pip install git+https://github.com/lab-cosmo/i-pi.git\n",
    "```\n",
    "If these steps don't work, try looking at the `README.rst` files of the respective repositories for further instructions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing all the necessary Librascal modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us start from the import of all the necessary modules and classes. In `librascal`, these are: \n",
    "\n",
    "1) the SOAP descriptors of a structure, by means of the `SphericalInvariants` class;\n",
    "\n",
    "2) the kernels between a set of environments and the sparse set (the `Kernel` class);\n",
    "\n",
    "3) the GAP model itself, which is saved as an object of the `KRR` class. The predict method of the same class will allow us to give predictions to new unseen structures. \n",
    "\n",
    "NOTE: it is assumed that the input format for the training set and the test set is an ASE-compatible (e.g. extended-XYZ) file, which is then converted into an array of ASE Atoms objects, each one corresponding to a specific structure. `librascal` uses these frames to compute the representations and predict the properties of new structures. In this example on zundel cations, the target energies to build the model with are reported in the `zundel_energies.txt` file, while the atomic forces are additional columns of the xyz. \n",
    "\n",
    "Alternatively, global target properties can be reported in the header line following the ASE format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pylab as plt\n",
    "\n",
    "import ase\n",
    "from ase.io import read, write\n",
    "from ase.build import make_supercell\n",
    "from ase.visualize import view\n",
    "import numpy as np\n",
    "# If installed -- not essential, though\n",
    "try:\n",
    "    from tqdm.notebook import tqdm\n",
    "except ImportError:\n",
    "    tqdm = (lambda i, **kwargs: i)\n",
    "\n",
    "from time import time\n",
    "\n",
    "from rascal.models import Kernel, train_gap_model, compute_KNM\n",
    "from rascal.representations import SphericalInvariants\n",
    "from rascal.utils import from_dict, to_dict, CURFilter, dump_obj, load_obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/ssd/local/code/librascal-zundel/examples/i-PI/zundel\n"
     ]
    }
   ],
   "source": [
    "cd i-PI/zundel/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the snippets below we extract the relevant properties for each ASE frame. We load the total potential energies and we use the `ASE.Atoms.arrays` methods to get the atomic forces. For more information on how to use ASE-related methods, check the [ASE Atoms documentation](https://wiki.fysik.dtu.dk/ase/ase/atoms.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['numbers', 'positions', 'forces'])\n"
     ]
    }
   ],
   "source": [
    "# Load the first N structures of the zundel dataset\n",
    "N_dataset = 1000\n",
    "frames = read('zundel_dataset.xyz', index=':{}'.format(N_dataset))\n",
    "energies = np.loadtxt('zundel_energies.txt')[:N_dataset] \n",
    "\n",
    "#Keys of the arrays dictionary\n",
    "print(frames[0].arrays.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "init_cell": true
   },
   "outputs": [],
   "source": [
    "def extract_forces(frames,array_key='zeros'):\n",
    "    f = []\n",
    "    for frame in frames:\n",
    "        if array_key is None:\n",
    "            pass\n",
    "        elif array_key == 'zeros':\n",
    "            f.append(np.zeros(frame.get_positions().shape))\n",
    "        else:\n",
    "            f.append(frame.get_array(array_key))\n",
    "    try:\n",
    "        f = np.concatenate(f)\n",
    "    except:\n",
    "        pass\n",
    "    return f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build the GAP model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The preliminary step towards building a GAP model is defining a training and a test set. The training set is built by random selection of $800$ of the available structures, while the remaining $200$ will represent the test set. At this point, we also extract the distinct atomic species present in our system, define the atomic baseline energy and extract the information regarding energies and forces in the train and test set structures, which we will need later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Number of structures to train the model with\n",
    "n = 800\n",
    "\n",
    "global_species = set()\n",
    "for frame in frames:\n",
    "    global_species.update(frame.get_atomic_numbers())\n",
    "global_species = np.array(list(global_species))\n",
    "\n",
    "# Select randomly n structures for training the model\n",
    "ids = list(range(N_dataset))\n",
    "np.random.seed(10)\n",
    "np.random.shuffle(ids)\n",
    "\n",
    "train_ids = ids[:n]\n",
    "frames_train = [frames[ii] for ii in ids[:n]]\n",
    "y_train = [energies[ii] for ii in ids[:n]]\n",
    "y_train = np.array(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_train = extract_forces(frames_train, 'forces')\n",
    "f = extract_forces(frames, 'forces')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Atomic energy baseline\n",
    "atom_energy_baseline = np.mean(energies)/(frames[0].get_global_number_of_atoms())\n",
    "energy_baseline = {int(species): atom_energy_baseline for species in global_species}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we proceed with the actual calculation of the SOAP vectors of our training set. We need to specify an hyperparameters dictionary, which `librascal` uses to compute the structural features. The meaning of each hyperparameter and how to correctly set them is reported in [the `SphericalInvariants` documentation](https://lab-cosmo.github.io/librascal/reference/python.html#rascal.representations.SphericalInvariants). These hyperparameters can be used as default values, but a careful optimization of the interaction cutoff might be required in the case the material under investigation might present some mid- or long-range order. \n",
    "\n",
    "For the actual calculation of the SOAP features, we first create an object of the `SphericalInvariants` class, defined by its hyperparameters. The methods that we then need to use are `transform()}`, which yields a second object called the `manager` containing the representation, while `get_features()` converts it into an $NxM$ matrix, $N$ being the number of atomic environments in the training set and M the number of features per each environment. \n",
    "\n",
    "At this point, the `compute_gradients` hyper should be set to `False`. For now, we will only use the SOAP representations (no gradients!) of the training set structures to select a sparse set using the CUR decomposition. Setting it to `True` would require Librascal to compute all the gradients of the SOAP representation w.r.t. atomic coordinates, thus making the structural managers unnecessarily memory expensive. We will instead compute later on the gradients of the sparse kernels using the `compute_KNM` method when we fit the GAP model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the parameters of the spherical expansion\n",
    "hypers = dict(soap_type=\"PowerSpectrum\",\n",
    "              interaction_cutoff=3.0, \n",
    "              max_radial=6, \n",
    "              max_angular=4, \n",
    "              gaussian_sigma_constant=0.5,\n",
    "              gaussian_sigma_type=\"Constant\",\n",
    "              cutoff_function_type=\"RadialScaling\",\n",
    "              cutoff_smooth_width=0.5,\n",
    "              cutoff_function_parameters=\n",
    "                    dict(\n",
    "                            rate=1,\n",
    "                            scale=3.5,\n",
    "                            exponent=4\n",
    "                        ),\n",
    "              radial_basis=\"GTO\",\n",
    "              normalize=True,\n",
    "              optimization=\n",
    "                    dict(\n",
    "                            Spline=dict(\n",
    "                               accuracy=1.0e-05\n",
    "                            )\n",
    "                        ),\n",
    "              compute_gradients=False\n",
    "              )\n",
    "\n",
    "\n",
    "soap = SphericalInvariants(**hypers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following snippet computes the descriptors and the managers for each frame, which will represent the expensive part of the calculation, in terms of memory usage.\n",
    "\n",
    "NOTE: the `librascal` structure manager only works if the atoms have been wrapped within the cell provided in the input file using e.g. `ase.Atoms.wrap()`, or one of the structure preprocessors provided in `rascal.neighbourlist.structure_manager` module (useful especially for non-periodic structures)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d5ce53e036fa4f378480913fc7369c6a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=800.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Execution:  0.12206697463989258 s\n"
     ]
    }
   ],
   "source": [
    "managers = []\n",
    "for f in tqdm(frames_train):\n",
    "    f.wrap(eps=1e-18)\n",
    "\n",
    "start = time()\n",
    "managers = soap.transform(frames_train)\n",
    "print (\"Execution: \", time()-start, \"s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, we can define the **sparse set**, i.e. the set of (ideally) \"maximally diverse\" environments that will be used as basis points of the kernel ridge regression (KRR, mostly equivalent to GAP) model. We can choose the number of sparse environments in `librascal` per each atomic species, by defining a dictionary containing (atomic number, number of environments) pairs. The CURFilter class then selects out the most \"representative\" environments according to the representation that we provide as the input object and by applying the CUR decomposition [3].\n",
    "\n",
    "[3]: 1 M.W. Mahoney and P. Drineas, PNAS 106, 697 (2009). https://doi.org/10.1073/pnas.0803205106"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of pseudo points selected by central atom species is: {1: 50, 8: 100}\n",
      "Selecting species: 1\n",
      "Reconstruction RMSE=1.463e+00\n",
      "Selecting species: 8\n",
      "Reconstruction RMSE=1.577e-02\n"
     ]
    }
   ],
   "source": [
    "# select the sparse points for the sparse kernel method with CUR on the whole training set\n",
    "n_sparse = {1:50, 8:100}\n",
    "compressor = CURFilter(soap, n_sparse, act_on='sample per species')\n",
    "X_sparse = compressor.select_and_filter(managers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown in eq. $(1)$, in order to fit a GAP potential we need to compute the kernels of all the training structure descriptors and the sparse set, as well as the gradients w.r.t. the atomic positions, if we wish to fit the atomic forces. We do so by using another key structure of librascal: the `Kernel` class. We first build a kernel object containing the representation (SOAP), which we then use to compute the sparse kernel matrix $K_{NM}$ between the training set and the sparse set and its gradients using the `compute_KNM` method.\n",
    "\n",
    "Finally, we group everything together to build the GAP model, which basically uses the kernel matrices to regress the weights $\\{\\alpha_s\\}_{s=1}^M$ on each sparse environment. The `lambdas` are the regularization parameters of the KRR (for both energies and forces), while `jitter` is a small parameter that enables its numerical convergence. \n",
    "\n",
    "The output is a KRR object, which we can save as .json file for future use. For this last bit we use the `dump_obj` method (part of the `rascal.utils.io` module)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "27249c466afd4deb8c92ee912ee53c82",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value='Computing kernel matrix'), FloatProgress(value=0.0, max=800.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Execution:  1.5349509716033936 s\n"
     ]
    }
   ],
   "source": [
    "zeta = 2\n",
    "\n",
    "start = time()\n",
    "hypers['compute_gradients'] = True\n",
    "soap = SphericalInvariants(**hypers)\n",
    "kernel = Kernel(soap, name='GAP', zeta=zeta, target_type='Structure', kernel_type='Sparse')\n",
    "\n",
    "KNM = compute_KNM(tqdm(frames_train, leave=True, desc=\"Computing kernel matrix\"), X_sparse, kernel, soap)\n",
    "\n",
    "model = train_gap_model(kernel, frames_train, KNM, X_sparse, y_train, energy_baseline, \n",
    "                        grad_train=-f_train, lambdas=[1e-12, 1e-12], jitter=1e-13)\n",
    "\n",
    "# save the model to a file in json format for future use\n",
    "dump_obj('zundel_model.json', model)\n",
    "np.savetxt('Structure_indices.txt', ids)\n",
    "print (\"Execution: \", time()-start, \"s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assessment of the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To perform a basic assessment of the model we have fitted, we need to predict the properties (energies and forces) of a test set. In the calculation of the model that we have fitted previously, we have randomly splitted the original dataset in a training set of 800 structures and a test set of another 200.\n",
    "So first we load the model and the indices corresponding to the shuffled dataset: the first 800 of those will correspond to the training set, the last 200 to the test set.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 800\n",
    "model = load_obj('zundel_model.json')\n",
    "ids = np.loadtxt('Structure_indices.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ids = [int(i) for i in ids[:n]]\n",
    "test_ids = [int(i) for i in ids[n:]] \n",
    "\n",
    "frames_train = [frames[ii] for ii in train_ids]\n",
    "frames_test = [frames[ii] for ii in test_ids]\n",
    "\n",
    "y_train = [energies[ii] for ii in train_ids]\n",
    "y_train = np.array(y_train)\n",
    "y_test = [energies[ii] for ii in test_ids]\n",
    "y_test = np.array(y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now compute the predictions on the test set, using the `predict()` and `predict_forces()` methods of the `KRR` class. At this point we need to compute the SOAP representation of the test set structures. It is important to stress however that this will not cause any issue regarding memory usage, because all we need is the predictions, so we can compute the managers of the test set structures one by one and calculate the predictions right away. Instead for the GAP fitting we need to store ALL the structure managers of the training set to perform the regression (which causes a large RAM usage)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "080b3e3ced374a8898f4ba9277884fba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=200.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# make predictions on the test set\n",
    "y_pred = []\n",
    "f_pred = []\n",
    "\n",
    "for f in tqdm(frames_test):\n",
    "    positions = f.get_positions()\n",
    "    f.set_positions(positions+[1,1,1])\n",
    "    f.wrap(eps=1e-18)\n",
    "    m = soap.transform(f)\n",
    "    y_pred.append(model.predict(m))\n",
    "    f_pred.append(model.predict_forces(m))\n",
    "\n",
    "y_pred = np.array(y_pred).flatten()\n",
    "f_pred = np.array(f_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_test = extract_forces(frames_test, 'forces')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now compute the overall performance of the model. This is done by calculation of the Root-Mean-Square Error (RMSE), i.e. the standard deviation of the residuals according to the standard formula:\n",
    "\n",
    "$$\n",
    "       \\text{RMSE} = \\sqrt{\\frac{1}{n_{\\text{test}}}\\sum_i (y_{\\text{pred}}^{i} - y_{\\text{test}}^{i})^2}\n",
    "$$\n",
    "   \n",
    "which we can compare to the standard deviation of the test set itself to quantify how much the model captures the energy variations in the test set. The $\\% \\text{RMSE}$ of our model is about $5 \\%$ of the training set STD, which is sufficiently accurate to run MD safely. \n",
    "\n",
    "Finally we plot a \"correlation plot\", to observe how well the predictions on the test set correlate with the reference DFT-computed energies.\n",
    "\n",
    "NOTE: by just repeating this procedure and fitting potentials with increasing training set size, one can also construct the learning curve of the GAP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RMSE =  30.087996494496597 meV\n",
      "Sigma test set =  0.274800153468654  eV\n",
      "%RMSE =  10.949046466936812  %\n"
     ]
    }
   ],
   "source": [
    "from rascal.utils import get_score\n",
    "\n",
    "score = get_score(y_pred, y_test)\n",
    "RMSE = score['RMSE']\n",
    "sigma_test = np.std(y_test)\n",
    "print(\"RMSE = \", RMSE*1000.0, \"meV\")\n",
    "print(\"Sigma test set = \", sigma_test, \" eV\")\n",
    "print(\"%RMSE = \", RMSE/sigma_test*100.0, \" %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'reference energies [eV]')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(y_test, y_pred, s=5.0, c = 'black')\n",
    "lims = [\n",
    "    np.min([np.min(y_pred), np.min(y_test)]),  # min of both axes\n",
    "    np.max([np.max(y_pred), np.max(y_test)]),  # max of both axes\n",
    "]\n",
    "\n",
    "# now plot both limits against eachother\n",
    "plt.plot(lims, lims, 'k-', zorder=0, color='red')\n",
    "plt.title(\"correlation plot\")\n",
    "plt.xlabel(\"predicted energies [eV]\")\n",
    "plt.ylabel(\"reference energies [eV]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MD simulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to use the fitted model to perform a simple NVT simulation at $\\text{T} = 250\\,$K using the i-Pi interface with librascal. For that we will use a communication socket run by i-Pi, which basically outputs a structure produced by the MD and gives it in input to Librascal. This will in turn return energies, forces and stresses by means of the `GenericMDCalculator` class of Librascal. \n",
    "\n",
    "The job itself will generate a parent process (i-Pi) which contains information of the ensemble, the step needed for the time-integration, the thermostat characteristics, and all other trajectory-related infos. All these information are initially stored in an input.xml file as specified in the i-Pi documentation at https://github.com/lab-cosmo/i-pi and given as inputs to i-Pi. The Librascal calculator is then launched as a child process and exchanges information with the MD driver.  \n",
    "\n",
    "The Librascal driver in i-Pi needs some input parameters, that can be given directly in the command line when the driver is called. To check the needed information, just use the --help option when calling it, as shown below.\n",
    "\n",
    "NOTE: in what follows, it is assumed that your i-Pi and Librascal folders lie in a common directory. Check and modify the path below when defining IPI if this is not the case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the XML file in the `i-PI/zundel` folder to quickly read the relevant information about the MD settings. Importantly, the `<properties>` tag gives you information about the physical properties that are printed out by i-PI. This simulation gives as output a .out file containing the time-evolution of all the relevant physical quantities, while the .xc.xyz file contains the full trajectory, which you can later visualize with VMD. The file `h5o2+.xyz` is both used by i-PI as a starting configuration of the trajectory and by Librascal as a template to load information about chemical species and number of atoms per species of the system.\n",
    "\n",
    "As the simulation evolves you can plot some interesting physical properties, for instance the MD kinetic energy, the total potential energy and the pressure, and check for thermalization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example script is provided to launch a MD simulation with i-PI and the model that has just been fitted `zundel_model.json` (note that you may need to edit some variables in the script, or set `$PATH` and `$PYTHONPATH` appropriately, in order to make it work on your system):\n",
    "\n",
    "```bash\n",
    "bash ./run.sh\n",
    "```\n",
    "\n",
    "and the simulation can be monitored with the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0, 'time [ps]')]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plotting the results of the simulations\n",
    "try:\n",
    "    f = open('zundel.out', 'r')\n",
    "except FileNotFoundError:\n",
    "    f = open('zundel.example.out', 'r')\n",
    "lines=f.readlines()[13:]\n",
    "\n",
    "Nframes = len(lines)\n",
    "steps = np.zeros((Nframes, 1), dtype=float)\n",
    "time = np.zeros((Nframes, 1), dtype=float)\n",
    "KE = np.zeros((Nframes, 1), dtype=float)\n",
    "PE = np.zeros((Nframes, 1), dtype=float)\n",
    "Pressure = np.zeros((Nframes, 1), dtype=float)\n",
    "\n",
    "i = 0\n",
    "for x in lines: \n",
    "    steps[i] = float(x.split()[0])\n",
    "    time[i] = float(x.split()[1])\n",
    "    KE[i] = float(x.split()[4])\n",
    "    PE[i] = float(x.split()[5])\n",
    "    Pressure[i] = float(x.split()[6])\n",
    "    i += 1\n",
    "\n",
    "f, axs = plt.subplots(2, 1, sharex=True, figsize=(12, 8))\n",
    "f.subplots_adjust(hspace=0)\n",
    "f.suptitle('T = 250 K', fontweight='bold')\n",
    "\n",
    "axs[0].plot(time, (KE - KE[0]), linewidth = 1.5, label = 'Change in Potential energy')\n",
    "axs[0].plot(time, (PE - PE[0]), linewidth = 1.5, label = 'Change in Kinetic energy')\n",
    "axs[0].set(ylabel= 'Energy [eV]')\n",
    "axs[0].set_ylim(-0.5, 0.5)\n",
    "axs[0].legend(ncol = 2, mode='expand', prop={'size': 12}, loc=\"lower center\")\n",
    "\n",
    "axs[1].plot(time, Pressure, linewidth = 1.5, color = 'red')\n",
    "axs[1].set(ylabel= 'MD Pressure [bar]')\n",
    "axs[1].set(xlabel= 'time [ps]')"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Initialization Cell",
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "12px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}