notebooks/gamma_surface_parallel_master.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementation of Gamma Surface calculation \n",
    "The Gamma Surface calculation requires multiple calculations, therefore we use the ParallelMaster Class and implement a ParallelMaster for Gamma Surface calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:05.421240Z",
     "start_time": "2020-08-13T10:44:03.899519Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pylab as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:09.910523Z",
     "start_time": "2020-08-13T10:44:05.422635Z"
    }
   },
   "outputs": [],
   "source": [
    "from pyiron import Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class templates \n",
    "We import two additional classes the AtomisticParallelMaster and the JobGenerator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:09.914123Z",
     "start_time": "2020-08-13T10:44:09.912113Z"
    }
   },
   "outputs": [],
   "source": [
    "from pyiron.atomistics.master.parallel import AtomisticParallelMaster\n",
    "from pyiron_base.master.parallel import JobGenerator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## JobGenerator\n",
    "The JobGenerator has three primary functions:\n",
    "* `parameter_list()` which generates a list of parameters, each parameter can then be executed in parallel. \n",
    "* `job_name()` a function to rename the temlate job using one parameter out of the parameter list. \n",
    "* `modify_job()` the function which modifies the job based on one parameter out of the parameter list. \n",
    "Finally there is one additional function to construct the structures the `get_structure()` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:09.920203Z",
     "start_time": "2020-08-13T10:44:09.915189Z"
    }
   },
   "outputs": [],
   "source": [
    "class GammaJobGenerator(JobGenerator):\n",
    "    @property\n",
    "    def parameter_list(self):\n",
    "        \"\"\"\n",
    "\n",
    "        Returns:\n",
    "            (list)\n",
    "        \"\"\"\n",
    "        parameter_lst = []\n",
    "        structure = self._master.ref_job.structure\n",
    "        x_max = structure.cell[0, 0]\n",
    "        y_max = structure.cell[1, 1]\n",
    "        x_vec = np.linspace(0, x_max, self._master.input[\"n_mesh_x\"])\n",
    "        y_vec = np.linspace(0, y_max, self._master.input[\"n_mesh_y\"])\n",
    "        for x in x_vec:\n",
    "            for y in y_vec:\n",
    "                parameter_lst.append([structure.copy(), x,y])\n",
    "        return parameter_lst\n",
    "\n",
    "    @staticmethod\n",
    "    def job_name(parameter):\n",
    "        return 'x_{:.4}_y_{:.4}'.format(parameter[1], parameter[2]).replace('.', '_')\n",
    "\n",
    "    def modify_job(self, job, parameter):\n",
    "        job.structure = self.get_structure(structure=parameter[0], x=parameter[1], y=parameter[2])\n",
    "        return job\n",
    "    \n",
    "    @staticmethod\n",
    "    def get_structure(structure, x, y):\n",
    "        z = structure.positions[:, 2]\n",
    "        z_0 = np.mean(z)\n",
    "        structure.positions[z < z_0, 0] += x\n",
    "        structure.positions[z < z_0, 1] += y\n",
    "        structure.add_tag(selective_dynamics=[False, False, True])\n",
    "        structure.pbc[2] = True\n",
    "        return structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ParallelMaster\n",
    "The ParallelMaster includes the JobGenerator as an object and in addition adds auxiliary functions to simplify the interaction of the user with the class. In this case these are the `collect_output()` function which summarizes the results of the individual collection as well as two plot functions the regular `plot()` function and the `plot2d()` function to visualise the results. In general the ParallelMaster primarly implements the functionality to aggregate the data once the calculation is finished. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:09.929631Z",
     "start_time": "2020-08-13T10:44:09.921173Z"
    }
   },
   "outputs": [],
   "source": [
    "class GammaSurface(AtomisticParallelMaster):\n",
    "    def __init__(self, project, job_name):\n",
    "        super(GammaSurface, self).__init__(project, job_name)\n",
    "        self.__name__ = \"GammaSurface\"\n",
    "        self.__version__ = \"0.0.1\"\n",
    "        self.input[\"n_mesh_x\"] = 10\n",
    "        self.input[\"n_mesh_y\"] = 10\n",
    "        self._job_generator = GammaJobGenerator(self)\n",
    "        self._output = {}\n",
    "    \n",
    "    def collect_output(self):\n",
    "        if self.server.run_mode.interactive:\n",
    "            ham = self.project_hdf5.inspect(self.child_ids[0])\n",
    "            self._job_generator.parameter_list\n",
    "            erg_lst = ham[\"output/generic/energy_tot\"]\n",
    "            _, x_lst, y_lst = zip(*self._job_generator.parameter_list)\n",
    "        else:\n",
    "            erg_lst, x_lst, y_lst = [], [], []\n",
    "            for job_id in self.child_ids:\n",
    "                ham = self.project_hdf5.inspect(job_id)\n",
    "                erg_lst.append(ham[\"output/generic/energy_tot\"][-1])\n",
    "                job_name = ham.job_name\n",
    "                x_lst.append(float(job_name.split(\"_y_\")[0].split(\"x_\")[1].replace('_', '.')))\n",
    "                y_lst.append(float(job_name.split(\"_y_\")[1].replace('_', '.')))\n",
    "        self._output[\"energy\"] = erg_lst\n",
    "        self._output[\"x\"] = x_lst\n",
    "        self._output[\"y\"] = y_lst\n",
    "        with self.project_hdf5.open(\"output\") as hdf5_out:\n",
    "            for key, val in self._output.items():\n",
    "                hdf5_out[key] = val\n",
    "                \n",
    "    def plot(self):\n",
    "        if len(self._output) > 0:\n",
    "            plt.plot(self._output[\"y\"], self._output[\"energy\"], 'x-'); \n",
    "        \n",
    "    def plot2d(self):\n",
    "        plt.imshow(np.reshape(self._output[\"energy\"], (self.input[\"n_mesh\"][0],-1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example Project\n",
    "To demonstrate the useage of the newly implemented class we create a small example project. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:44:10.771291Z",
     "start_time": "2020-08-13T10:44:09.930539Z"
    }
   },
   "outputs": [],
   "source": [
    "pr = Project(\"Gamma_parallel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execution \n",
    "We use interactive LAMMPS jobs and calculate the gamma surface for two fcc crystal orientations namely 111 and 100. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-08-13T10:46:44.992356Z",
     "start_time": "2020-08-13T10:44:12.574387Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The job gamma_fcc111 was saved and received the ID: 1\n",
      "The job gamma_fcc111_ref_job was saved and received the ID: 2\n",
      "The job gamma_fcc100 was saved and received the ID: 3\n",
      "The job gamma_fcc100_ref_job was saved and received the ID: 4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmeUlEQVR4nO2df6xk5Xnfv99e9i7xZr3rdh1A7AXiFcJrRwLDiuJaqmhEyo9apZaIhKWGyIq0JcWSI0Wq3PzhNP2r/zSNMAmrTYMwaurIIsHZWoupSY2MpeKw4AWDF9QFsdxbYCl2ubss4V52+/SPO7M7OzPnnPc95/3xvOc8H2l0586cOfPMM8/5vt/znPecoYjAMAzDKJ+/lzsAwzAMIwwm6IZhGD3BBN0wDKMnmKAbhmH0BBN0wzCMnmCCbhiG0ROcBZ3kAskfk/zOnOdI8l6SR0k+T/LasGEaRhysro0+4ePQvwLgSMVztwK4cnTbC+D+jnEZRiqsro3e4CToJHcC+GcA/nPFIrcDeEg2eArAdpKXBIrRMKJgdW30jQscl/sjAP8GwNaK5y8FsDzx/8rosTcnFyK5FxtOBwu44LotF3ys8Y3lwsWZx85cyNrXnJl9iRML6+1e50NVbLI4/4zdxcXTlev66AUftI7jYwvvOy33f898pPV7nDh94cxj6+uzJcf187/P6e9h4YPZ3PCD+i/rxOn/846IfLwhxD9CgLoG5tf2vNodc2YzJ+6fe3xeHdTVQA6mv8OZ729t8v78up73/Q0lX8D5OXPJF3AuZ3W13SjoJD8P4G0ReYbkjVWLzXlsJjIR2Q9gPwBs2/RL8o92/Hrte69/cufcx1d3bZ77+JiTl9cLfhVbj8W/DEJVbGtL8wXqsqV3Ktd100Uvd47njm3PVD738Op1ndb9+PGrZh57fXnHzGObl8/fkKe/h22vrGGaxZdWat/7u2/9ybG650PWNTCntv/BHVjfvTR3paufOL9+T15x7m3m1UFdDeSg6Tvc+tq5FG17dfa7G7N4ZPm8/y1fbvn67vH7K2vbxaF/DsA/J3kbgAsBfJTkfxGRfzmxzAqAyW9jJ4A3HNYdnLZiPn5tClHXxFi0J4W9q5CHZnXX5rmi3pGodV0lTtNMilMobr646pDAfB57a3fwGMasfmJzpUit7146K1Ku+YpBifmqorGHLiL/VkR2isgVAO4E8D+mih4ADgC4azQr4AYAqyIys1vqQ1t3PiTmOeC2PLx63dlbCELGFoNcde2Lr9v0Fae2r6kjxiAVa919y5drD30GkncDgIjsA3AQwG0AjgJ4H8CXgkTnSRd3PrmOHC598/JiZdvFSEeIuq7rBU+3Dybp8v13FZnx613c52VL78xtI7ShizPv0m7Jna+1pfWZVqML67uXgOPVz3sJuog8AeCJ0f19E48LgHu8o6ugr+68zYDz+vIOdT3BkLQpamCjRpr66K6kqusYhHaLN198pFVLoU6g6toITdQNgG3Qkq86uuRL3ZmiVWLeRAh3HmNdxjlCuboxbWslF9rFaXK9sdbtw5Dz1fazqxN0ww/tvepQlL53No+m3mndnlkKwQ35HiHEuUuvWXu+QvXRVQl6neOq26BjOGpz6WVQiktvEjSf/rkG99zEPIHyEfU2+aoaADXkq03btM0gqEbQS9kwY1LVgwzdqugbVjvxqBLDeQJlB/X9Bo8Y+VIh6Fo3yFJc+lDaLnVorSEgfC+4ZFxyYfk6h28usgu6y4aYut1idCPXAKNR1Ks2yJhztUvG8tWN7IKuHRswykKjqDdRWj/YlSoRjuHAS8hXUx89RL6yCrq581na9tGH0HZxnemiRdT70jqI0UeflxvXfGnv1cfoo7vmJpug151Np40+Dhyp8Tmwa/k2jHYU23JJvdF3fb8U8Q7BpZdCnaOyfvAGkzmyfDXj4tJVC3ofTybpQgnTF21QOf/a3W0ooR/sSgox1pivtu/dNV+qBb0KV7e7trQ+9xb7fXNigloW2vvBY3z66D6sfmKz17GGUvJVRdf5+025KlLQXahLUiiBj0XbC1YNAdtr04/GbWooqBV0rRtubpeuue1iewfNdLl+S6l0aSMMsX/e5TOrFPSuUxV9HYLv8rlFvQkTVp1ov7hUW2INQi750tg/b4rBJV9ta0WloHfBdvf0oXmvIiel1WruqwmWlq8cqBP0XCcSleTSXQQytUu3vYJ6htY6mLc9+eTA8tUuB6oEvWvfvE8juB0Y7Q+uG6bm9kFKuuZryDQKOskLSf4tyedIvkjyD+YscyPJVZKHR7evhQ40hSMuyaW7oN01tx20Qh0w11LbJdF1+mIK561pAEydL5ffFF0D8Ksi8h7JTQB+SPJREXlqarknReTzXu8+QanuPNePSmv6rdEYA0eivEav7aoNsk97k76cvILY+tr879byNUtdvqZpdOiywXujfzeNbkG3NE1TFGMUTk4nr92l5yR2bfu4Ky2Dc0i893gH1jefJoT2OPXQSS6QPAzgbQDfE5EfzVnss6Nd10dJfrpzZBM0CWJoEdbSerE+enxy13YTmtoHTfgMSl3Fuw/HG2Lky0nQReSMiFwDYCeA60n+ytQizwK4XESuBvB1AN+etx6Se0keInlo/cNTAHS58y6cvJxqe+oxXXrMdafIZ4zaPv3BqV67zVCiOZkjy1czLjnymuUiIu8CeALALVOPnxjvuorIQQCbSM7MrROR/SKyR0T2LG7a4iTmqd151/WmFPYS5nfHinF11+aztxCErG1u21L7XkPuBxtxcZnl8nGS20f3fwHATQBemlrmYpIc3b9+tN6f1a33zIX9HZEB/TNg+kRbcY9V2770sX/uyskr2Og8pwfAPuerabBvypWLQ78EwPdJPg/gaWz0Gb9D8m6Sd4+WuQPACySfA3AvgDtFJP4UhchOp+v6NbVhYrRGNB5w9RR2tbUNlNUPHjMttin3RvqQr640TlsUkecBfGbO4/sm7t8H4L6gkcFcLrBxYLRuo/CZvvj48atw00UvhwotCTGnL+as7dK5+eIjeOyt3bnDKIZU+VJ1pqgPqUZ+63caIRliPXX5zJYvP9QKurnzOIRqk2hst2hn3oba535wV4aSr64/ejGJWkGvI/Word0llDDbpQtDHNxL7AePCSlQrpSQrxQxupz6n5whbsApSdVL7/tA40NqU/CFj/7YablHTswcQnDGty+8trTufLJcH/Pli0++xqhz6LnmnTeR06XbGaNlU1U7sdoHruLku2wIXLYjy9c5fHVHnaCH4rKld2ZufcbXDXfpgVv/3B2tTrPra5pou71ZvrqhStBju/MhCXzfGFIbrm2vtYvQpHSeoUW7pHy1idUnX6oEPRSuYu0r7H1ru5jTjkvKegkhyG3W0VZM5+VmCPlqi2tu1Ah6KHc+ZOfd5iCkj6g/fvwqGwQcaarXkHUaUlhyiZTlq/kzumigCkHPvTtdikvPiQYhz10nrshi+zNbfR1v6oN0PqQwVxry5bvOmNMXVQh6E+bON4g126VOrNu6cpuyGJ9YYp5SoNaW1pOZJM2DnytNucou6KFcV1cx74tLDymkMV35kKdihjAescVJk/iVYNS05CuroLuIeUrxLKFwYjEp3pp75aW0Xdqg7WzHECIVc5vyyVcKwfV5j64/Hl1FdocegiEJsYuzbevSNQu5cQ4tbnASbYPRJCnzlfu7ySboZxz2uF3ceWgxd12f5raLoZfSzEdul15avkLQ5TP3wqEbxiRa2zJ1G6pmh5uLvuer7jO0FXW1gp7DnfuuN5dLj9l2KYEqwdb0C1HThKrVHLv0ru8ZQ6C6ojlfMVAr6E0McVfMmGUs4lqF3DiHzzZr23e7HKgUdA39ae0uXTMp9g5KEvGmWnJtH+Q+4BYCl+1qSPlq+iy+ot4o6CQvJPm3JJ8j+SLJP5izDEneS/IoyedJXusVhSepRm/NLmHobZcQpKhtzTXkQ4i2y5i6nAwtXy745MTFoa8B+FURuRrANQBuIXnD1DK3ArhydNsL4H7nCKbfzByvkY6otd0XcUqF5asa19w0Crps8N7o302j2/TFKm4H8NBo2acAbCd5iUe8APIeCO3yfjYIlUnK2q6iT+0DH9puxyXlK+RejStOPXSSCyQPA3gbwPdE5EdTi1wKYHni/5XRY9Pr2UvyEMlDZ06dahmyMcbaLt2JUtsnT/XSbcYUqD7mKwdOgi4iZ0TkGgA7AVxP8lemFpl3dGrmknMisl9E9ojInoUtW7yDNfTjMoBouo5LlNrearXtgom4Hy758prlIiLvAngCwC1TT60AWJr4fyeAN3zWrbHdUgKaXHrJewMxa9swUuEyy+XjJLeP7v8CgJsAvDS12AEAd41mBNwAYFVE3gwdbJ/Zeqz9NbQ1Od4mNMVqtW30jQsclrkEwDdILmBjAPiWiHyH5N0AICL7ABwEcBuAowDeB/ClSPFm4bKld5K4z0lRDz3H+vXlHVH3cAp151Fqe3HxdNAgNRzgi0nouux7vupoFHQReR7AZ+Y8vm/ivgC4p20QQ2+3zHPn48dchX3z8mJjHmOLemmkqO2+8YWP/hiPnJhJWWv6Xo8x8nWs5nmVZ4oa59h6TDq1Y1Lg6s41tVs00IcLTBm6MEEvBBdR13SA1DBCYwNgM9kFPWa75aaLXm71ur4TUtTNnRtGd0INVtkFPRZjMb/popdVC7tPOyWUSw+Fuf34lHqAL5ebLjVfoeitoE+jWdRzkFKMzZ33i6GLpi8p85VV0GO1W6rEW7tbdyGkS+8i6ubODUMfg3Hok7QR9aaBpc0FutrOXtE+68UwjDyoFvSQ7nzecqW79TpiunSf11i7xTDSkU3QZVGHyyxV1EO6dB+BtlZLOqxXbfii2qH7Uqo4t6VJ1EO549eXd5y9+WDuvBqbUx0ezQNgqthcruWSBd92S2lirq0PPnlZAHPhRhOhT2lvwgZAN3rl0NtS2mAwSUiX3saFh3hfwzDCDFq9EPSSBdkIj/0koA7MVadHpaBrvQJbqLhCt1u0tW+M7mjuBxt6USnoPoRy56W7/DpRT93+sHaLkZoSBsAUMRYv6IZh5KEEER0a6gTdp61RoqvO1R5J5ZrNnRtGPtQJek60DhDbXllzWq4PvfSun8EOiBpDxuVHopdIfp/kEZIvkvzKnGVuJLlK8vDo9rU44Z5Dq/iGYtsra2dv4/+7Ets9d1l/jl9mylXbNvvDiIXLiUWnAfyuiDxLciuAZ0h+T0R+OrXckyLy+fAhDos64d72yhpWd22uff3WY1L7O6Quvz3ahq5ingmVtW296fNpGgD7lK+bLz6Cx97a3fr1jQ5dRN4UkWdH908COALg0tbvWINr/zynO+8ydbFOuCbd+FDI/XupKWu7rzSJqe2NnE/swcerh07yCmz8SvqP5jz9WZLPkXyU5KcrXr+X5CGSh86cPOUfbQK0t3JcRD/VNV66rE9bvz9kbX/47vsxQzWMSpwFneQvAvhLAL8jIiemnn4WwOUicjWArwP49rx1iMh+EdkjInsWtm5pFbB2wU1B6U6+Sczbin3bVlLo2t60/SOt4jCMrjgJOslN2Cj4PxeRv5p+XkROiMh7o/sHAWwi6XVREK1nh4ZCmyMN5dJ916MtDylq2zBS4TLLhQD+DMAREfnDimUuHi0HkteP1vuzkIEC6dx56r2ANo676TXahFMjmmrbMELgMsvlcwB+A8BPSB4ePfZ7AC4DABHZB+AOAL9N8jSAvwNwp4iYokTGZdZLHV1nvJTuzpGhtu0goR+WLz8aBV1Efgigeh7cxjL3AbivbRAu7ZYSeudrS+vJz5SsE/WmKYx9os3AlKK2je5T8YZGl3zZmaIVlDCAhKDtANQDd66SPs2pNtJjgt4CbQdwtc96MTHfwNoH4SlxAIwZc3ZB70u7RSsuYurrtu0CXMYkLgLVZjAb8gDY9rNnF3TNpBhIQrnrVC7dWi2GoRe1PxI9xtx5d1wOjk7PeCnJhdsVFg1jg6wOXVsvunS6uvTNy4tnbyHo4s775uyH3D5og+WrXQ5Ut1w0uPMQMWgQp9QxaPjMhi5MpOOjWtCNcyy+tJI7BMMwlJNN0BcXT9c+r8Gd1xGiXeTaIvERcw1TGFO68xL65+ZM/bB8tcccunImxbyrS7c2iG5KnFPti4m1H775MkFXzDwBdxH1nC7dBg0jFSUPgLFiVyno2tstKagT7i5O3QTXiEHJ4tonVAq6NjQOMBoPktpgMYu1GGapy4nlaxafnJigZ6KuLRJCrOvW3xfhrTogauc3GENFnaBrdMMp8RFzTS69L4OEYZSMOkEfMm0Euq2omwDHx9oHfli+umOC3oGQu/Zd3HbVa1PNdok1ONig019MvP1wzZcJ+oDpo2Ba/9wYMi4/Er1E8vskj5B8keRX5ixDkveSPEryeZLXtgkmZP/8jm3PnL2lJNeZi7lceq5BIUSeY9a2rwO1aX9GCFwc+mkAvysiuwHcAOAekp+aWuZWAFeObnsB3B80Sg/miXgIUQ852Gg4PX/MwK+IWFRt943JQW+IA6DvZ3DJUaOgi8ibIvLs6P5JAEcAXDq12O0AHpINngKwneQlXtF2pMmN53DrqdE066UESqntUuiDyJaOVw+d5BUAPgPgR1NPXQpgeeL/FcxuGCC5l+Qhkoc+fPd9z1D7iwlxfqy2jT7gLOgkfxHAXwL4HRE5Mf30nJfM7I+LyH4R2SMiezZt/4hfpA08vHodHl69rnEZjax/cqeq9QwN7bVdCo+c+EzuEAaP00/QkdyEjYL/cxH5qzmLrABYmvh/J4A3uofnz1i0J9srIYT88eNXdV7HmNVdm9X00Zt+mq7ptaX30Uuq7b7x2Fu7c4eQFd8B0CVfLrNcCODPABwRkT+sWOwAgLtGMwJuALAqIm/6BAuEFc2xY0/tynP9FmeVO1/dtTlxJGkIkeeYte0rVkN3t5avMLg49M8B+A0APyF5ePTY7wG4DABEZB+AgwBuA3AUwPsAvhQ8UiM4Xdz55Do0ufTXl3f4zEW32jZ6RaOgi8gPMb+POLmMALgnVFBDZP2TO1sfHO2rOw8x4NRhtZ2PobdbYmFninbg9eUdQdfX5qBm2wOhIcUytvCWiomWH5avalxzo07QQ/bRS8RHoG1Wi2EYk6gT9KEQux1St/4YjjqHS686MBp6z8kwSsEEXSEuzlujO7fWi+FCXfvA2i6z+OREpaBra7vkiKdOsLuIuYluWoYiUDaNUAcqBd3YYJ5wu4h5ztktNmAYRjOxBkATdOVobK0YcRiCyw25x2L5miWboK+v10+B19Z2mSbEgTdXJz0W9a7uPJV7TunSc52Z68NQ2i6hsHy1xxx6IZhTNwyjCdWCrsGlh4hBQ185dQwaPrOhC3Pe8ckq6DZfOCxdD4auLa1n+wm9afo2IJiY+WH5apcD1Q4d0OHSS8dXHMfCPn2L/b5tKaGPbhgpUC/oOUkxmGi5gJaLYLcR9r45bcPQTHZBd2m7mEtvpsvAoKXNYpSJy/RBa6H40TZf2QW9RLT1/lNPVTSX3g4TNT/6mq+Y8+dN0CsYyl5BW3durj4OQzhZJiSWr/NRIeh9abvkODin4UQiF2LHYgdG9dJXp60RFYJutCPENMWUr9c0wOTCxM2PIeary2d2+ZHoB0i+TfKFiudvJLlK8vDo9rXW0TRQgktvQ4yZLiaezWiqbcMIgYtDfxDALQ3LPCki14xu/75NIJoONMYYOEILbG533nY9ygaaB5Ggtg0jFY2CLiI/APDzBLE40VeX7oOWueuxSCX62mrbMLoSqof+WZLPkXyU5KerFiK5l+QhkofOnDwV6K2HhYuYNwli6BkqbVx6DNGOdGDUu7Y/fPf9GHEYRiMhBP1ZAJeLyNUAvg7g21ULish+EdkjInsWtm5p/YYxXXrTuru0hupErO+uex6xhD0grWp70/aPpIovO03TBod4ULOO2NMsOwu6iJwQkfdG9w8C2ESylepp6qPnYHXX5rO3quebSO3OQ6xXq6iHrG0fbG61H33KV9cBsLOgk7yYJEf3rx+t82dd19tE33vp0+Ledwev0a3Hqm1zrX5Yvtyp/9kgACS/CeBGADtIrgD4fQCbAEBE9gG4A8BvkzwN4O8A3CkiEi3iiGgdJFzFPJc7n1x/1z52V1HfvLzo/DmHVNvGMGgUdBH5YsPz9wG4L1RAry/vwGVL7zgt+/jxq3DTRS+HeusknLyc2Hqsv5oQQtRTkbq2DSM2dqboQLBrrxih6VPvui8UL+ih2iRa2y2uaOs/G0ZKShhcUsSoUtC1znYJFVdq8U3tzm1voDslCJShD5WC7kvp7ror5s7Pp5QevmGEpheC3pWSB4SQM1suW3rH+YB0E+bSDZtu6EeIfKkVdN/2RsmirIFJIR8LeyhxN4yu2ODghlpBb0NJoh6iTZJi3vmkuPsKvLn0akoXKOvx+5EqX9kEnes6+r4lDQKThOyb+wi1ufZ0mGj6YflS7tDbzCrxEehSxdwFV3fcRqB9XmMu3TDS0XimaB9pI+RNg0ubmRVtzxq1WS2GYcwjq0OPNb2sTrD77MrHxHTnIV5rGEYc1Dt0n2u71NEXIQ/lzlMKcknXdzGasV61HynzpbqH3oVJAdcs5j4C7bJsyp61ufT4lCqeuWbxlJqvUGQXdBfn1vaU+8ePX6VazHORQ4jt4KhhVBNqAMwu6IYbodx5aDE3l26kovS5+ykwQVeOxl/ymcZV1M2ln48JlBEaFYIes+1SAvME21fIc7hzY3iE7lH3ebuOQVO+VAi6dlIWXSxHHlvMbbA4x/q6+sljqgi9fWk6MJo6lkZBJ/kAybdJvlDxPEneS/IoyedJXhs+zP7TRchLamVoirWU2tYkUIZuXBz6gwBuqXn+VgBXjm57AdzfJpCht11ikso9F+jSH0SC2jaMVDQKuoj8AMDPaxa5HcBDssFTALaTvCRUgEY9mhyvK1pittrOixm08ITooV8KYHni/5XRYzOQ3EvyEMlDZ06dCvDWw0bjgdACXXod7Wr75KleipVr66fN7J0+5is0LjkKIejzGr9zrzglIvtFZI+I7FnYsmXmeY1tFyu0QdOutrfO1nYVruJnffQNSspXzAGwihCCvgJgaeL/nQDeaLuyEq/5UWLMhhOdatvMQDXzcmP5qsY1NyEE/QCAu0YzAm4AsCoibwZYbyWpvnjNBaax3dJDOte25hryIaTjrcuJ5WsWn5y4TFv8JoD/CeAqkiskf4vk3STvHi1yEMCrAI4C+FMA/9o/5PMpyfGWFGsqUgwkW49Jq2vJT5Kqtps2yJLaCE00fRYXcbJ8ncN3gGs8A0JEvtjwvAC4x+tdAxDqsrp16zf0Mxb1NnP4tdZ2X7Ftyo82+VJ7pmjOA6Su683lzofebpnnzMeOvatrj0XJYpbD6YbKV47Yc+4ZqBV0w2hLiaLehzZC3WdoI9Ah8qWZ0PkCMgr6gsO5JTlceslOytDPEOury2e2fPnRC4ee40vvY7vlpotexk0XvdzqtUY6Urp0zXsErgwpX1kF3WXXOKVwDtENjJkUcs2irrWdEgJtbQQfcaqKPeY2ZfmaJbtDD7WBphTjIUxVjO3WtVzPJQchajW2E8ztNCcpIV9ayC7oLrgKaN97dbHaLXXC3VbU+zzLRgt9EKmU5ihmvlJ9F035UiHouXejfcR8CO58Gi299dx14grX2/9AiW8bIYaQ+K6za+ujyzY1xHzVoULQXUjh0ksntDvvsuzQKdV5pjxlfTJHTfkKuV33IV9VqBH0kO7L9ct/fXlHMe5cS8/ZRN2dunrR+LNrKVs483JT2iCYO1/zUCPoQLOoh/jCxyI+ZCc/xsS5X3QRmLavbdM+CC3cbVsYpeTLB1WCHpKxYE8KeJ9F3LfdUpqYl9I/n6aNeHXZ6NsITQyn2XZbS70XXEK+fHKiTtBDuvSQAj7Eg6FVlDYY5KaqdmIZDB/BST1TxmU7snydw1d3Gq+2mIOtx6TV1fP6Suj+eSpBvmzpnV7vFWkmhfD47kn4iNPm5cWkx400TgFtYyLVOXQXUrtl7e6873O+S223TOJbQ9rOgtROCflKEaNaQe/DRqyRUO7c2i7+aDcGoZi3V9bms897TR/3+ELlC1As6FoYykZopGG6nvooUNN02YaGuP11+czFCvpQvuimPqJPu6VEV217ajopocWhiVT5chJ0kreQfJnkUZJfnfP8jSRXSR4e3b4WIrgU89Jjr7/PgqR1gNj2yprTcrnq2pUSRTPnHofly2GWC8kFAH8M4NcArAB4muQBEfnp1KJPisjnXd944YP+Ch2gT8i1im8oXEV8TKy6bkPs38fNSZMp2vqa4OQV9TPapme8DD1fdbg49OsBHBWRV0VkHcBfALjdNcA6XDbCXC697Xo1/65l39j2ytrZWwui1fVCQzhDaRe60iRShjsugn4pgOWJ/1dGj03zWZLPkXyU5KeDRFcYqYXc1aXEdOdN6+7ipOry2VLEJ4la130WqVCtjckcWb6accmRi6DP2x+aXvOzAC4XkasBfB3At+euiNxL8hDJQ+sfngKg06X7ri+WK9dyQa6eEqyugfNr+/QHp4IFWVJf2Kcf3FXAq96rr/lyxUXQVwAsTfy/E8AbkwuIyAkReW90/yCATSRnohWR/SKyR0T2LG7acvbxAG5LNTlbMH3vnXcgWF2Pnj9b2xdcuFHbPqLVx+mL3saoxy7dhbp8uebGRdCfBnAlyV8muQjgTgAHJhcgeTFJju5fP1rvz5wiGNFV1EO59DbuPAeaDgrFGDQS5DVJXVdtiEPuo9eJk+VrFp+BrlHQReQ0gC8DeAzAEQDfEpEXSd5N8u7RYncAeIHkcwDuBXCniATdIlMIZyli7op2d962pRRij05LXZdGjh+D9kVT2yV1LE4X5xrtbh6cemzfxP37ANzXNZhtr6xhddfm1q9PfUGfmPTlc2gmVV27TM0DqqfjPfbWbtx88ZGuYajAxW12zVcJuA6Avm0odWeK1rmvmI64JHfuUsSp3bn2vYHcDK0/PG978snB0PI1jzY5UCfoXRlyr00rpbqo2Fit+tHnfIX6bCoFPfWsl5LcuVEupbvOLv3zNp/d5TWapy+mzhegVNDrcBHTmCN5bjHX2G7J/b59QrNAtaXLQFb6INiGLp9ZraDHnsa4eXnx7E0bdkC0mtLPWRiCQGncpoaCyp+ga8L3J+pCFVhud+6CuWQjBrGmK257dQ2rn3Cf2danmWxjfPRp26v1hkatQwfCuPQ+uYUSDi7agAIsrLkP/D6/ylNi28Vlj6RJpJrQmK+2A2DXPTjVgl5Harfc9f1SxGtiqoc6kRpC28WFyRxZvppxGfiyCTo/6Nduk1FPCXsXhlE6WR364ksrjcvkOtEox/sA1QdEmwSxT+68Kt+uLTiXukpB11aCFnzaB64tznm56Uu+fOiSr3kU23JJRQkHQo1zaBFzH3yO85TUR69qlXQVbu3HHXJe7ya7oHd16YYxRqOYV4lXU19Y08WuUtI2X30gxACYXdCBbhtiTAddijvX1m7JEY9GMTdmcRGnIbZeqvDNhQpBB2yDBNr3z4eO9topWaB8WhZ9miLcltz5UiPoTaQ+OFqKOzfKoEnUS+ujt5lP7TOwtcmXpj76NG1aaG2MgCpB1+60NKKt3RKLqgG9zzVTJwIpREqDEE7SpY+uPV+hjhGoEnSg/QYa0lGbO49D6NZRaWI+7bi6bsQxRSr0utu4zdCtqr7nC1B6LZfFl1aw/smdM493/UWj3Pheg2YIrC2tt+ollibmsRgLSahfNGorTHXfoaZjCFryVUeXfKlz6F0I4axzuXM7IDoM6jbWLgfJugrLY2/tdl5HyCmVi0eWsXhkufJ5rfnyWUeXE7CmqcsV4CjoJG8h+TLJoyS/Oud5krx39PzzJK9tFe0EVQ7M5qSfI2T//I5tz5y9haCE3n6sug55WQsf8fQR5enXhSTmnPGQ8/e75CtkzkLmq7HlQnIBwB8D+DUAKwCeJnlARH46sditAK4c3f4hgPtHf5PTpa0xxN75PAEfP/bw6nWpw5lLjEE8dl0vHlnG+u6lxuVcfxDZB00HM+sc9qTbdM1XDDTlq44mdw64OfTrARwVkVdFZB3AXwC4fWqZ2wE8JBs8BWA7yUt8A57G+qTxcHHjody6UrLVtaaecgkMKV9dP6vLQdFLAUwODSuYdSnzlrkUwJuTC5HcC2Dv6N+17771Jy80vvtbcx57ovFVIdkBIFsj+1jNc0/OPuQc6+87R/CG85Kz/LeqJ1Lk9PKG54PVNTCnto/f/wKO17z7Ew3RTVBXAx3JWtszVOdrB55wjzNivlzIWtsugj5vf3C6N+GyDERkP4D9AEDykIjscXj/rJQSJ1BOrEriDFbXgNV2TEqJE8gfq0vLZQXAZHNrJ2Ztm8syhqEJq2ujd7gI+tMAriT5yyQXAdwJ4MDUMgcA3DWaFXADgFURmdktNQxFWF0bvaOx5SIip0l+GcBjABYAPCAiL5K8e/T8PgAHAdwG4CiA9wF8yeG997eOOi2lxAmUE2v2OCPWNaDg8zlicYYna6wUGd5UPcMwjD7SqzNFDcMwhowJumEYRk/IIuhNp1xrgeRrJH9C8jDJQ7njGUPyAZJvk3xh4rG/T/J7JP/X6O/HcsY4piLWf0fyf4/yepjkbTljDEUpdQ1YbXdFa10nF/SJU65vBfApAF8k+anUcXjwT0TkGmXzYB8EcMvUY18F8DciciWAvxn9r4EHMRsrAPynUV6vEZGDiWMKToF1DVhtd+FBKKzrHA7d5ZRrowYR+QGAn089fDuAb4zufwPAv0gZUxUVsfYRq+sAlFLbWus6h6BXnU6tEQHw30k+Mzq1WzMXjedIj/7+UuZ4mvjy6AqGD2jYhQ5ASXUNWG3HImtd5xB059OpFfA5EbkWG7vR95D8x7kD6gn3A9gF4BpsXBflP2aNJgwl1TVgtR2D7HWdQ9CLOZ1aRN4Y/X0bwCPY2K3WyvHxlQBHf9/OHE8lInJcRM6IyP8D8KfQnVdXiqlrwGo7BhrqOoegu5xynR2SW0huHd8H8E8BNF8dMh8HAPzm6P5vAvjrjLHUMnUJ2i9Ad15dKaKuAavtWGio6+S/KVp1ynXqOBy4CMAjJIGNPP1XEflu3pA2IPlNADcC2EFyBRtXw/0PAL5F8rcAvA7g1/NFeI6KWG8keQ02WhKvAfhXueILRUF1DVhtd0ZrXdup/4ZhGD3BzhQ1DMPoCSbohmEYPcEE3TAMoyeYoBuGYfQEE3TDMIyeYIJuGIbRE0zQDcMwesL/Bw00Mwz59S9QAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "surface_list = ['fcc111', 'fcc100']\n",
    "fig, ax_list = plt.subplots(ncols=2, nrows=1, sharex=True)\n",
    "\n",
    "potential = '2009--Mendelev-M-I--Al-Mg--LAMMPS--ipr1'\n",
    "for i, surf in enumerate(surface_list):\n",
    "    with pr.open(surf) as pr_test:\n",
    "        ax= ax_list[i]\n",
    "        Al = pr_test.create_surface('Al', surf, (1,2,12), vacuum=10, orthogonal=True)\n",
    "        ref_job = pr_test.create_job(pr_test.job_type.Lammps, 'ref_job')\n",
    "        ref_job.structure = Al\n",
    "        ref_job.potential = potential\n",
    "        ref_job.calc_minimize()\n",
    "        ref_job.interactive_enforce_structure_reset = True\n",
    "        ref_job.server.run_mode.interactive = True\n",
    "        gs = ref_job.create_job(GammaSurface, \"gamma_\" + surf)\n",
    "        gs.input[\"n_mesh_x\"] = 5\n",
    "        gs.input[\"n_mesh_y\"] = 19\n",
    "        gs.run()\n",
    "        ax.contourf(np.reshape(gs._output[\"energy\"], (gs.input[\"n_mesh_x\"],-1)))"
   ]
  },
  {
   "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.7.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "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": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}