{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# useful to autoreload the module without restarting the kernel\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mppi import InputFiles as I, Calculators as C, Utilities as U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "omp = 1\n",
    "mpi = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial for the YamboCalculator class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial describes the usage of the YamboCalculator class, that manages the run of (many) calculations in\n",
    "parallel with the Yambo package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform an Hartree-Fock computation for Silicon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Follow the tutorial for the QeCalculator to produce the .save folder needed to generate the yambo SAVE.__\n",
    "\n",
    "The first step needed to perform a Yambo computation is to generate the SAVE folder from a QuantumESPRESSO\n",
    "computation. \n",
    "\n",
    "The mppi.Utilities module has a function that perform this task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "source_dir = 'QeCalculator_test/bands_8.save'\n",
    "run_dir = 'YamboCalculator_test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create folder YamboCalculator_test\n",
      "Executing command: cd QeCalculator_test/bands_8.save; p2y -a 2\n",
      "Create a symlink of /home/marco/Applications/MPPI/sphinx_source/tutorials/QeCalculator_test/bands_8.save/SAVE in YamboCalculator_test\n",
      "Executing command: cd YamboCalculator_test;OMP_NUM_THREADS=1 yambo\n"
     ]
    }
   ],
   "source": [
    "U.build_SAVE(source_dir,run_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the YamboInput class can create the yambo input object.\n",
    "\n",
    "We consider a HF computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'args': 'yambo -x -V rl',\n",
       " 'folder': 'YamboCalculator_test',\n",
       " 'filename': 'yambo.in',\n",
       " 'arguments': ['HF_and_locXC'],\n",
       " 'variables': {'FFTGvecs': [2133.0, 'RL'],\n",
       "  'SE_Threads': [0.0, ''],\n",
       "  'EXXRLvcs': [3000.0, 'mHa'],\n",
       "  'VXCRLvcs': [13107.0, 'RL'],\n",
       "  'QPkrange': [[1, 2, 1, 8], '']}}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exx = 3.0 # Hartree\n",
    "inp = I.YamboInput(args='yambo -x -V rl',folder=run_dir)\n",
    "inp.set_kRange(1,2) #restrict the analysis to the first two kpoints\n",
    "inp['variables']['EXXRLvcs'] = [exx*1e3,'mHa']\n",
    "name = 'hf_exx'+str(exx)\n",
    "jobname = 'hf_job_exx'+str(exx)\n",
    "inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To run the computation we create an istance of YamboCalculator. This object behaves almost exactly as\n",
    "the QeCalculator for what concerns the user interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mInit signature:\u001b[0m\n",
       "\u001b[0mC\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mYamboCalculator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0momp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'1'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mmpi\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mmpi_run\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mpirun -np'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mexecutable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'yambo'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mscheduler\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'direct'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mskip\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mclean_restart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m     \n",
       "Perform a Yambo calculation. Computations are managed by a scheduler that,\n",
       "in the actual implementation of the class, can be `direct` or `slurm`.\n",
       "\n",
       "Parameters:\n",
       "   omp (:py:class:`int`) : value of the OMP_NUM_THREADS variable\n",
       "   mpi (:py:class:`int`) : number of mpi processes\n",
       "   mpi_run (:py:class:`string`) : command for the execution of mpirun, e.g. 'mpirun -np' or 'mpiexec -np'\n",
       "   executable (:py:class:`string`) : set the executable (yambo, ypp, yambo_rt, ...) of the Yambo package\n",
       "   scheduler (:py:class:`string`) : choose the scheduler used to submit the job, actually the choices implemented are\n",
       "        'direct' that runs the computation using the python subprocess package and 'slurm' that creates a slurm script\n",
       "   skip (:py:class:`bool`) : if True evaluate if the computation can be skipped. This is done by checking that the folder\n",
       "        where yambo write the results contains at least one file 'o-*'\n",
       "   clean_restart (:py:class:`bool`) : if True delete the folder with the output files and the database before running the computation\n",
       "   verbose (:py:class:`bool`) : set the amount of information provided on terminal\n",
       "   kwargs : other parameters that are stored in the _global_options dictionary\n",
       "\n",
       " Example:\n",
       " >>> code = YamboCalculator(omp=1,mpi=4,mpi_run='mpirun -np',executable='yambo',skip=True,verbose=True,scheduler='direct')\n",
       " >>> code.run(input = ..., run_dir = ...,name = ...,jobname = ..., **kwargs)\n",
       "\n",
       " where the arguments of the run method are:\n",
       "\n",
       "Args:\n",
       "    run_dir (:py:class:`string`) : the folder in which the simulation is performed\n",
       "    input (:py:class:`string`) : instance of the :class:`YamboInput` class\n",
       "        that define the input objects\n",
       "    name (:py:class:`string`) : string with the names associated to the input file (without extension).\n",
       "        This string is used also as the radical of the folders in which results are written as well as a\n",
       "        part of the name of the output files.\n",
       "    jobname (:py:class:`string`) : string with the values of the jobname. If this variable is not specified\n",
       "        the value of name is attributed to jobname by process_run.\n",
       "    kwargs : other parameters that are stored in the run_options dictionary\n",
       "\n",
       "When the run method is called the class runs the command:\n",
       "            executable_name -F name.in -J jobname -C name\n",
       "\n",
       "The calculator looks for the following variables in the run_options dictionary. These options\n",
       "may be useful for _asincronous_ computation managed the slurm scheduler.\n",
       "\n",
       "    `dry_run=True` with this option the calculator setup the calculations and write the scrpt\n",
       "    for submitting the jobs, but the computations are not run.\n",
       "\n",
       "    `wait_end_run=False` with this option the wait of the end of the run is suppressed.\n",
       "\n",
       "    `sbatch_options = [option1,option2,....]` allows the user to include further options in the slurm script\n",
       "\u001b[0;31mFile:\u001b[0m           ~/Applications/MPPI/mppi/Calculators/YamboCalculator.py\n",
       "\u001b[0;31mType:\u001b[0m           type\n",
       "\u001b[0;31mSubclasses:\u001b[0m     \n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "C.YamboCalculator?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Yambo calculator with scheduler direct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'omp': 1,\n",
       " 'mpi': 4,\n",
       " 'mpi_run': 'mpirun -np',\n",
       " 'executable': 'yambo',\n",
       " 'scheduler': 'direct',\n",
       " 'skip': True,\n",
       " 'clean_restart': True,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code = C.YamboCalculator(omp=omp,mpi=mpi)\n",
    "code.global_options()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The structure of the folder in which yambo writes its results is governed by the name and jobname \n",
    "variables. It is possible to provide only the name variable. \n",
    "\n",
    "The effect of this choice can be seen in the command string executed by the calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delete folder: YamboCalculator_test/hf_exx3.0\n",
      "run command: cd YamboCalculator_test; mpirun -np 4 yambo -F hf_exx3.0.in -J hf_exx3.0 -C hf_exx3.0\n",
      "computation hf_exx3.0 is running...\n",
      "computation hf_exx3.0 ended\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/hf_exx3.0/o-hf_exx3.0.hf'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1',\n",
       " 'HF_and_locXC': 'YamboCalculator_test/hf_exx3.0/ndb.HF_and_locXC'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(run_dir = run_dir, input = inp, name= name,skip=False)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case yambo create the hf_exx3.0 folder and write all the files in these folders. Result is a dictionary that contain the names\n",
    "of the o- file and the databases created by yambo.\n",
    "\n",
    "Instead, if we set also set a jobname we have"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delete folder: YamboCalculator_test/hf_exx3.0\n",
      "delete folder: YamboCalculator_test/hf_job_exx3.0\n",
      "run command: cd YamboCalculator_test; mpirun -np 4 yambo -F hf_exx3.0.in -J hf_job_exx3.0 -C hf_exx3.0\n",
      "computation hf_exx3.0 is running...\n",
      "computation hf_exx3.0 ended\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/hf_exx3.0/o-hf_job_exx3.0.hf'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1',\n",
       " 'HF_and_locXC': 'YamboCalculator_test/hf_job_exx3.0/ndb.HF_and_locXC'}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run( run_dir=run_dir, input=inp ,name=name,jobname=jobname,skip=False)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case yambo creates also the folders hf_job_exx and write the databases in these folders."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage of the skip parameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we repeat a calculation that has been already performed and skip = True the class skip its computation, for instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip the run of hf_exx3.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/hf_exx3.0/o-hf_job_exx3.0.hf'],\n",
       " 'dbs': 'YamboCalculator_test/hf_exx3.0'}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(run_dir = run_dir, input = inp, name= name, skip = True)\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test of the slurm scheduler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the `slurm` scheduler is chosen the calculator prepare the slurm script and submit it. The effects of skip and\n",
    "multiTask parameters can be tested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = code.run(run_dir=run_dir,inputs=inputs,names=names, scheduler = 'slurm', skip = False, multiTask = True)\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slurm script is written in the run_dir. The execution of the run requires that the slurm scheduler is installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform a GW computation for Silicon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We make usage of the YamboCalculator to perform a different yambo computation. In this way we control\n",
    "how this class manage the output files and the ndb database in various cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = I.YamboInput(args='yambo -d -k hartee -g n -p p -V qp',folder=run_dir)\n",
    "inp.set_kRange(1,2)\n",
    "#inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip the run of qp_test1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/qp_test1/o-qp_test1.qp'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1',\n",
       " 'pp': 'YamboCalculator_test/qp_test1/ndb.pp',\n",
       " 'QP': 'YamboCalculator_test/qp_test1/ndb.QP',\n",
       " 'HF_and_locXC': 'YamboCalculator_test/qp_test1/ndb.HF_and_locXC',\n",
       " 'dipoles': 'YamboCalculator_test/qp_test1/ndb.dipoles'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(input = inp, run_dir = run_dir, name='qp_test1')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform the same computation but specify also a jobname "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip the run of qp_test2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/qp_test2/o-qp_job_test2.qp'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1',\n",
       " 'pp': 'YamboCalculator_test/qp_job_test2/ndb.pp',\n",
       " 'QP': 'YamboCalculator_test/qp_job_test2/ndb.QP',\n",
       " 'HF_and_locXC': 'YamboCalculator_test/qp_job_test2/ndb.HF_and_locXC',\n",
       " 'dipoles': 'YamboCalculator_test/qp_job_test2/ndb.dipoles'}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(input = inp, run_dir = run_dir, name='qp_test2', jobname = 'qp_job_test2')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test of the ExtendOut option in the input file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ExtendOut option enables the writing of all the variables in the output files of Yambo. \n",
    "This feature has no effect for an HF computation and we test for a QP one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "inp = I.YamboInput(args='yambo -d -k hartee -g n -p p -V qp',folder=run_dir)\n",
    "inp.set_kRange(1,2)\n",
    "inp.set_extendOut()\n",
    "#inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skip the run of qp_test_ExtendOut\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/qp_test_ExtendOut/o-qp_test_ExtendOut.qp'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1',\n",
       " 'pp': 'YamboCalculator_test/qp_test_ExtendOut/ndb.pp',\n",
       " 'QP': 'YamboCalculator_test/qp_test_ExtendOut/ndb.QP',\n",
       " 'HF_and_locXC': 'YamboCalculator_test/qp_test_ExtendOut/ndb.HF_and_locXC',\n",
       " 'dipoles': 'YamboCalculator_test/qp_test_ExtendOut/ndb.dipoles'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(input = inp, run_dir = run_dir,name='qp_test_ExtendOut')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can check that the o- files contain more information. These feature is managed by the YamboParser class of the package."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perform a ypp computation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The YamboCalculator class can manage also ypp computation.\n",
    "\n",
    "Let's see an example by performing a band calculation along a path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'args': 'ypp -s b',\n",
       " 'folder': 'YamboCalculator_test',\n",
       " 'filename': 'ypp.in',\n",
       " 'arguments': [],\n",
       " 'variables': {'OutputAlat': [0.0, ''],\n",
       "  'INTERP_Shell_Fac': [20.0, ''],\n",
       "  'INTERP_NofNN': [1.0, ''],\n",
       "  'BANDS_steps': [10.0, ''],\n",
       "  'INTERP_mode': 'NN',\n",
       "  'cooIn': 'rlu',\n",
       "  'cooOut': 'rlu',\n",
       "  'CIRCUIT_E_DB_path': 'none',\n",
       "  'PROJECT_mode': 'none',\n",
       "  'BANDS_bands': [[1, 8], '']}}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inp = I.YamboInput(args='ypp -s b',folder=run_dir,filename='ypp.in') \n",
    "inp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a calculator for ypp. This calculation requires 1 mpirun (see yambo for further information)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialize a Yambo calculator with scheduler direct\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'omp': '1',\n",
       " 'mpi': 1,\n",
       " 'mpi_run': 'mpirun -np',\n",
       " 'executable': 'ypp',\n",
       " 'scheduler': 'direct',\n",
       " 'skip': False,\n",
       " 'clean_restart': True,\n",
       " 'verbose': True}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "code = C.YamboCalculator(mpi=1,executable='ypp',skip=False)\n",
    "code.global_options()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the input parameter to perform the band computation along a path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in alat\n",
    "G = [0.,0.,0.]\n",
    "X = [1.,0.,0.]\n",
    "L = [0.5,0.5,0.5]\n",
    "K = [1.0,0.5,0.]\n",
    "path = [L,G,X,K,G]\n",
    "\n",
    "band_range = [2,5]\n",
    "bands_step = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'args': 'ypp -s b',\n",
       " 'folder': 'YamboCalculator_test',\n",
       " 'filename': 'ypp.in',\n",
       " 'arguments': [],\n",
       " 'variables': {'OutputAlat': [0.0, ''],\n",
       "  'INTERP_Shell_Fac': [20.0, ''],\n",
       "  'INTERP_NofNN': [1.0, ''],\n",
       "  'BANDS_steps': [30, ''],\n",
       "  'INTERP_mode': 'NN',\n",
       "  'cooIn': 'alat',\n",
       "  'cooOut': 'alat',\n",
       "  'CIRCUIT_E_DB_path': 'none',\n",
       "  'PROJECT_mode': 'none',\n",
       "  'BANDS_bands': [[2, 5], ''],\n",
       "  'BANDS_kpts': [[[0.5, 0.5, 0.5],\n",
       "    [0.0, 0.0, 0.0],\n",
       "    [1.0, 0.0, 0.0],\n",
       "    [1.0, 0.5, 0.0],\n",
       "    [0.0, 0.0, 0.0]],\n",
       "   '']}}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# scissor\n",
    "# inp['variables']['GfnQP_E'] = [1.0,1.0,1.0]\n",
    "\n",
    "# band structure\n",
    "# Some methods that perform these operation can be added in the YamboInput class\n",
    "inp['variables']['BANDS_steps'] = [bands_step,'']\n",
    "inp['variables']['BANDS_bands'] = [band_range,'']\n",
    "inp['variables']['BANDS_kpts'] = [path,'']\n",
    "inp['variables']['cooIn'] = 'alat'\n",
    "inp['variables']['cooOut'] = 'alat'\n",
    "inp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delete folder: YamboCalculator_test/bands_test1\n",
      "run command: cd YamboCalculator_test; mpirun -np 1 ypp -F bands_test1.in -J bands_test1 -C bands_test1\n",
      "computation bands_test1 is running...\n",
      "computation bands_test1 ended\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/bands_test1/o-bands_test1.bands_interpolated'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1'}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(run_dir=run_dir,input=inp,name='bands_test1')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Result can be parsed using the YamboParser class of this package or other external tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test the jobname specification for this type of computations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delete folder: YamboCalculator_test/bands_test2\n",
      "run command: cd YamboCalculator_test; mpirun -np 1 ypp -F bands_test2.in -J bands_job_test2 -C bands_test2\n",
      "computation bands_test2 is running...\n",
      "computation bands_test2 ended\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': ['YamboCalculator_test/bands_test2/o-bands_job_test2.bands_interpolated'],\n",
       " 'dft': 'YamboCalculator_test/SAVE/ns.db1'}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = code.run(run_dir=run_dir,input=inp,name='bands_test2',jobname='bands_job_test2')\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}