examples/job/run-simulations-and-extract-properties.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "pe8t1uEoGuQL"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/Exabyte-io/api-examples/blob/dev/examples/job/run-simulations-and-extract-properties.ipynb\" target=\"_parent\">\n",
    "<img alt=\"Open in Google Colab\" src=\"https://user-images.githubusercontent.com/20477508/128780728-491fea90-9b23-495f-a091-11681150db37.jpeg\" width=\"150\" border=\"0\">\n",
    "</a>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "XZhBV89lGuQN"
   },
   "source": [
    "# Run Simulations and Extract Properties\n",
    "\n",
    "This example demonstrates how to use Mat3ra RESTful API to create simulation [Jobs](https://docs.mat3ra.com/jobs/overview/) programmatically for multiple [Materials](https://docs.mat3ra.com/materials/overview/) at once and extract the resulting [Properties](https://docs.mat3ra.com/properties/overview/) forming a [Pandas](https://pandas.pydata.org/) dataframe.\n",
    "\n",
    "This approach can work with any [Workflows](https://docs.mat3ra.com/workflows/overview/). For the demonstration purpose we use the Density Functional Theory and extract Electronic Band Gap as the property of interest.\n",
    "\n",
    "> <span style=\"color: orange\">**IMPORTANT NOTE**</span>: In order to run this example in full, an active Mat3ra.com account with access to VASP (Vienna ab-initio simulations package) is required. Alternatively, Readers may substitute the workflow ID below with another one (an equivalent one for Quantum ESPRESSO, for example) and adjust extraction of the results (\"Extract results\" section). RESTful API credentials shall be updated in [settings](../../utils/settings.json).\n",
    "\n",
    "\n",
    "## Steps\n",
    "\n",
    "We follow the below steps:\n",
    "\n",
    "- Import materials from [materials project](https://materialsproject.org/)\n",
    "\n",
    "- Group imported materials inside a [materials set](https://docs.mat3ra.com/entities-general/sets/)\n",
    "\n",
    "- Create jobs for the materials and grouping them inside a [jobs set](https://docs.mat3ra.com/entities-general/sets/)\n",
    "\n",
    "- Submit jobs and monitoring the progress\n",
    "\n",
    "- Extract the [final structure](https://docs.mat3ra.com/properties/structural/final-structure) (relaxed structure) and its properties\n",
    "\n",
    "- Output the results as Pandas dataFrame\n",
    "\n",
    "## Pre-requisites\n",
    "\n",
    "The explanation below assumes that the reader is familiar with the concepts used in Mat3ra platform and RESTful API. We outline these below and direct the reader to the original sources of information:\n",
    "\n",
    "- [Generating RESTful API authentication parameters](../system/get_authentication_params.ipynb)\n",
    "- [Importing materials from materials project](../material/import_materials_from_materialsproject.ipynb)\n",
    "- [Creating and submitting jobs](../job/create_and_submit_job.ipynb)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "ML9cpWslGuQO"
   },
   "source": [
    "# Complete Authorization Form and Initialize Settings\n",
    "\n",
    "This will also determine environment and set all environment variables. We determine if we are using Jupyter Notebooks or Google Colab to run this tutorial.\n",
    "\n",
    "If you are running this notebook from Google Colab, Colab takes ~1 min to execute the following cell.\n",
    "\n",
    "ACCOUNT_ID and AUTH_TOKEN - Authentication parameters needed for when making requests to [Mat3ra.com's API Endpoints](https://docs.mat3ra.com/rest-api/endpoints/).\n",
    "\n",
    "MATERIALS_PROJECT_API_KEY - Authentication parameter needed for when making requests to [Material Project's API](https://materialsproject.org/open)\n",
    "\n",
    "ORGANIZATION_ID - Authentication parameter needed for when working with collaborative accounts https://docs.mat3ra.com/collaboration/organizations/overview/\n",
    "\n",
    "> <span style=\"color: orange\">**NOTE**</span>: If you are running this notebook from Jupyter, the variables ACCOUNT_ID, AUTH_TOKEN, MATERIALS_PROJECT_API_KEY, and ORGANIZATION_ID should be set in the file [settings.json](../../utils/settings.json) if you need to use these variables. To obtain API token parameters, please see the following link to the documentation explaining how to get them: https://docs.mat3ra.com/accounts/ui/preferences/api/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tZDgVj8zGuQO",
    "outputId": "fd8048ca-7813-46fb-f340-49a306eaff0c"
   },
   "outputs": [],
   "source": [
    "# @title Authorization Form\n",
    "ACCOUNT_ID = \"ACCOUNT_ID\"  # @param {type:\"string\"}\n",
    "AUTH_TOKEN = \"AUTH_TOKEN\"  # @param {type:\"string\"}\n",
    "MATERIALS_PROJECT_API_KEY = \"MATERIALS_PROJECT_API_KEY\"  # @param {type:\"string\"}\n",
    "ORGANIZATION_ID = \"ORGANIZATION_ID\"  # @param {type:\"string\"}\n",
    "\n",
    "import os\n",
    "import sys\n",
    "\n",
    "if \"COLAB_JUPYTER_IP\" in os.environ:\n",
    "    os.environ.update(\n",
    "        dict(\n",
    "            ACCOUNT_ID=ACCOUNT_ID,\n",
    "            AUTH_TOKEN=AUTH_TOKEN,\n",
    "            MATERIALS_PROJECT_API_KEY=MATERIALS_PROJECT_API_KEY,\n",
    "            ORGANIZATION_ID=ORGANIZATION_ID,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    !GIT_BRANCH=\"dev\"; export GIT_BRANCH; curl -s \"https://raw.githubusercontent.com/Exabyte-io/api-examples/${GIT_BRANCH}/scripts/env.sh\" | bash\n",
    "\n",
    "if sys.platform == \"emscripten\":\n",
    "    apiConfig = data_from_host.get(\"apiConfig\")\n",
    "    os.environ.update(data_from_host.get(\"environ\", {}))\n",
    "    os.environ.update(\n",
    "        dict(\n",
    "            ACCOUNT_ID=apiConfig.get(\"accountId\"),\n",
    "            AUTH_TOKEN=apiConfig.get(\"authToken\"),\n",
    "            MATERIALS_PROJECT_API_KEY=MATERIALS_PROJECT_API_KEY,\n",
    "            ORGANIZATION_ID=apiConfig.get(\"organizationId\") or \"\",\n",
    "        )\n",
    "    )\n",
    "\n",
    "    import micropip\n",
    "\n",
    "    await micropip.install(\"mat3ra-api-examples\", deps=False)\n",
    "    await micropip.install(\"exabyte-api-client\")\n",
    "    from utils.jupyterlite import install_packages\n",
    "\n",
    "    await install_packages(\"\", \"../../config.yml\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "jS3-0-VzGuQP"
   },
   "source": [
    "### Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jC7WQVLkGuQP"
   },
   "outputs": [],
   "source": [
    "import time\n",
    "from IPython.display import IFrame\n",
    "\n",
    "# Import settings file and utils file\n",
    "from utils.settings import ENDPOINT_ARGS, ACCOUNT_ID, MATERIALS_PROJECT_API_KEY\n",
    "from utils.generic import wait_for_jobs_to_finish, get_property_by_subworkflow_and_unit_indicies, dataframe_to_html\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "# Relevant functions from the API client\n",
    "from exabyte_api_client.endpoints.jobs import JobEndpoints\n",
    "from exabyte_api_client.utils.materials import flatten_material\n",
    "from exabyte_api_client.endpoints.projects import ProjectEndpoints\n",
    "from exabyte_api_client.endpoints.materials import MaterialEndpoints\n",
    "from exabyte_api_client.endpoints.bank_workflows import BankWorkflowEndpoints\n",
    "from exabyte_api_client.endpoints.properties import PropertiesEndpoints"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "8qFzDd1EGuQQ"
   },
   "source": [
    "#### Materials\n",
    "\n",
    "- **MATERIALS_PROJECT_IDS**: a list of material IDs to be imported from materials project\n",
    "- **TAGS**: a list of [tags](https://docs.mat3ra.com/entities-general/data/#tags) to assign to imported materials\n",
    "- **MATERIALS_SET_NAME**: the name of the materials set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GrESpSt6GuQQ"
   },
   "outputs": [],
   "source": [
    "MATERIALS_PROJECT_IDS = [\"mp-149\", \"mp-32\"]  # Si and Ge\n",
    "MATERIALS_SET_NAME = \"materials-set\"\n",
    "TAGS = [\"tag1\", \"tag2\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "tN2FjWMTGuQR"
   },
   "source": [
    "#### Jobs\n",
    "\n",
    "Parameters for the jobs to be ran for the imported materials:\n",
    "\n",
    "- **JOB_NAME_PREFIX**: prefix to be used for the job name with \"{JOB_NAME_PREFIX} {FORMULA}\" convention (e.g.  \"Job Name Prefix - SiGe\")\n",
    "- **JOBS_SET_NAME**: the name of the jobs set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7PK1884mGuQR"
   },
   "outputs": [],
   "source": [
    "JOB_NAME_PREFIX = \"Job Name Prefix\"\n",
    "JOBS_SET_NAME = \"jobs-set\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "2SL1nNOBGuQS"
   },
   "source": [
    "#### Workflow\n",
    "\n",
    "This example is based on [this](https://platform.mat3ra.com/bank/workflows/tPiF5dBQrY8pnik8r) bank workflow which is later copied to the account workflows collection.  The workflow is named \"D3-GGA-BS-BG-DOS-ALL\" and utilizes the logic explained in https://arxiv.org/pdf/1808.05325.pdf, for example (see section \"Methodology\", Table I). \"D3\" indicates the difficulty level 3 per the table convention. BS, BG, DOS indicate the properties extracted - Band Structure, Band Gap, Density of States. The workflow is utilizing VASP simulation engine at version 5.4.4."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "63K2z5V_GuQS"
   },
   "outputs": [],
   "source": [
    "BANK_WORKFLOW_ID = \"tPiF5dBQrY8pnik8r\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 671
    },
    "id": "K6IVdeN0GuQS",
    "outputId": "0f805c5b-0608-4af7-f8d8-914026559dab"
   },
   "outputs": [],
   "source": [
    "# Visualize the bank workflow below\n",
    "# NOTE: might not be rendered on Github\n",
    "IFrame(\"https://platform.mat3ra.com/analytics/workflows/{}\".format(BANK_WORKFLOW_ID), width=900, height=650)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "_bRgarl3GuQT"
   },
   "source": [
    "#### Compute\n",
    "\n",
    "Setup compute parameters. See [this](https://docs.mat3ra.com/infrastructure/compute-settings/ui) for more information about compute parameters.\n",
    "\n",
    "- **NODES**: Number of nodes. Defaults to 1.\n",
    "- **PPN**: Number of MPI processes per each node, Defaults to 1.\n",
    "- **QUEUE**: The name of queue to submit the jobs into. Defaults to D.\n",
    "- **TIME_LIMIT**: Job walltime. Defaults to \"01:00:00\" (one hour).\n",
    "- **CLUSTER**: The full qualified domain name (FQDN) or alias of the cluster to submit the jobs into.\n",
    "\n",
    "explain in the notebook that the job might run out of the limit of memory so it is clear, (2) suggest using OR queue to avoid memory limitations\n",
    "\n",
    "> <span style=\"color: orange\">**NOTE**</span>: Although here we set the QUEUE to be debug, it is possible the job might run out of memory, and result in an Errored-Jobs status. If this happens, we suggest you switch from `QUEUE = D` to `QUEUE = OR` to avoid memory limitations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_81ZxEGSGuQT"
   },
   "outputs": [],
   "source": [
    "PPN = \"1\"\n",
    "QUEUE = \"D\"\n",
    "NODES = \"1\"\n",
    "TIME_LIMIT = \"01:00:00\"\n",
    "CLUSTER = \"cluster-001\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "VeUh62vmGuQU"
   },
   "source": [
    "### Initialize endpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PDHqVPGsGuQU"
   },
   "outputs": [],
   "source": [
    "job_endpoints = JobEndpoints(*ENDPOINT_ARGS)\n",
    "project_endpoints = ProjectEndpoints(*ENDPOINT_ARGS)\n",
    "material_endpoints = MaterialEndpoints(*ENDPOINT_ARGS)\n",
    "property_endpoints = PropertiesEndpoints(*ENDPOINT_ARGS)\n",
    "bank_workflow_endpoints = BankWorkflowEndpoints(*ENDPOINT_ARGS)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "3-OhxFHxGuQU"
   },
   "source": [
    "Next, we retrieve the owner and project IDs as they are needed by the endpoints. Account's default material is used to extract the owner ID. One can extract the owner ID from any other account's [entities](https://docs.mat3ra.com/entities-general/overview/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "thRoaKNlGuQU"
   },
   "outputs": [],
   "source": [
    "owner_id = material_endpoints.list({\"isDefault\": True, \"owner._id\": ACCOUNT_ID})[0][\"owner\"][\"_id\"]\n",
    "project_id = project_endpoints.list({\"isDefault\": True, \"owner._id\": ACCOUNT_ID})[0][\"_id\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "BR22VXZQGuQU"
   },
   "source": [
    "### Create workflow\n",
    "\n",
    "Copy bank workflow (template) to the account's workflows collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RA7-aPNmGuQU"
   },
   "outputs": [],
   "source": [
    "workflow_id = bank_workflow_endpoints.copy(BANK_WORKFLOW_ID, owner_id)[\"_id\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "FNVGdNhaGuQU"
   },
   "source": [
    "### Import materials\n",
    "\n",
    "Import materials from materials project with the above tags."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4b2k3-9BGuQV"
   },
   "outputs": [],
   "source": [
    "materials = material_endpoints.import_from_materialsproject(\n",
    "    MATERIALS_PROJECT_API_KEY, MATERIALS_PROJECT_IDS, owner_id, TAGS\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "sb1JK5NNGuQV"
   },
   "source": [
    "Create a materials set and move the materials into it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sj5Hsk-8GuQV"
   },
   "outputs": [],
   "source": [
    "materials_set = material_endpoints.create_set({\"name\": MATERIALS_SET_NAME, \"owner\": {\"_id\": owner_id}})\n",
    "for material in materials:\n",
    "    material_endpoints.move_to_set(material[\"_id\"], \"\", materials_set[\"_id\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "PSVqliqZGuQV"
   },
   "source": [
    "### Create jobs\n",
    "\n",
    "Create jobs for the materials above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hqlJVk6-GuQV"
   },
   "outputs": [],
   "source": [
    "compute = job_endpoints.get_compute(CLUSTER, PPN, NODES, QUEUE, TIME_LIMIT)\n",
    "jobs = job_endpoints.create_by_ids(materials, workflow_id, project_id, owner_id, JOB_NAME_PREFIX, compute)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "xJZsmyetGuQV"
   },
   "source": [
    "Create a jobs set and move the jobs into it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bem3lHjPGuQV"
   },
   "outputs": [],
   "source": [
    "jobs_set = job_endpoints.create_set({\"name\": JOBS_SET_NAME, \"projectId\": project_id, \"owner\": {\"_id\": owner_id}})\n",
    "for job in jobs:\n",
    "    job_endpoints.move_to_set(job[\"_id\"], \"\", jobs_set[\"_id\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "dWzkeaCmGuQW"
   },
   "source": [
    "Submit the jobs for execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ah5gvnQdGuQW"
   },
   "outputs": [],
   "source": [
    "for job in jobs:\n",
    "    job_endpoints.submit(job[\"_id\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "UYvSw8PCGuQW"
   },
   "source": [
    "Monitor the jobs and print the status until they are all finished."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DBbJH6rhGuQW",
    "outputId": "8a4c5707-aa42-4daf-8ee5-d201ae9d00ac"
   },
   "outputs": [],
   "source": [
    "job_ids = [job[\"_id\"] for job in jobs]\n",
    "wait_for_jobs_to_finish(job_endpoints, job_ids)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EVs2s18ZGuQW"
   },
   "source": [
    "### Extract results\n",
    "\n",
    "For each material, simulaion job, final structure, pressure and band gaps are extracted.\n",
    "\n",
    "- Final structure and pressure are extracted from the first unit (vasp_relax with index 0) of the first job's subworkflow (volume-relaxation with index 0)\n",
    "\n",
    "- Band gaps are extracted from the second unit (vasp-bands with index 1) of the second job's subworkflow (SCF-BS-BG-DOS with index 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "d3f4eoHBGuQW"
   },
   "outputs": [],
   "source": [
    "results = []\n",
    "for material in materials:\n",
    "    job = next((job for job in jobs if job[\"_material\"][\"_id\"] == material[\"_id\"]))\n",
    "    final_structure = get_property_by_subworkflow_and_unit_indicies(property_endpoints, \"final_structure\", job, 0, 0)[\n",
    "        \"data\"\n",
    "    ]\n",
    "    pressure = get_property_by_subworkflow_and_unit_indicies(property_endpoints, \"pressure\", job, 0, 0)[\"data\"][\"value\"]\n",
    "    unit_flowchart_id = job[\"workflow\"][\"subworkflows\"][1][\"units\"][1][\"flowchartId\"]\n",
    "    band_gap_direct = property_endpoints.get_direct_band_gap(job[\"_id\"], unit_flowchart_id)\n",
    "    band_gap_indirect = property_endpoints.get_indirect_band_gap(job[\"_id\"], unit_flowchart_id)\n",
    "    results.append(\n",
    "        {\n",
    "            \"initial_structure\": material,\n",
    "            \"final_structure\": final_structure,\n",
    "            \"pressure\": pressure,\n",
    "            \"band_gap_direct\": band_gap_direct,\n",
    "            \"band_gap_indirect\": band_gap_indirect,\n",
    "        }\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "LHstXQ31GuQW"
   },
   "source": [
    "### Flatten results\n",
    "\n",
    "The below for-loop iterates over the results and flatten them to form the final Pandas dataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1k1GV4T4GuQX"
   },
   "outputs": [],
   "source": [
    "table = []\n",
    "for result in results:\n",
    "    data = flatten_material(result[\"initial_structure\"])\n",
    "    data.extend(flatten_material(result[\"initial_structure\"]))\n",
    "    data.extend([result[\"pressure\"], result[\"band_gap_direct\"], result[\"band_gap_indirect\"]])\n",
    "    table.append(data)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "uMo__G6uGuQX"
   },
   "source": [
    "### Output results\n",
    "\n",
    "Form the Pandas dataFrame headers according to the table generated above with the following abbreviations:\n",
    "\n",
    "- **\"INI\"**: INITIAL\n",
    "- **\"FIN\"**: FINAL\n",
    "- **\"N-SITES\"**: Number of Sites\n",
    "- **\"LAT\"**: LATTICE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NWYQp88JGuQX"
   },
   "outputs": [],
   "source": [
    "headers = []\n",
    "keys = [\"ID\", \"NAME\", \"TAGS\", \"NS\", \"LAT-A\", \"LAT-B\", \"LAT-C\", \"LAT-ALPHA\", \"LAT-BETA\", \"LAT-GAMMA\"]\n",
    "headers.extend([\"-\".join((\"INI\", key)) for key in keys])\n",
    "headers.extend([\"-\".join((\"FIN\", key)) for key in keys])\n",
    "headers.extend([\"PRESSURE\", \"DIRECT-GAP\", \"INDIRECT-GAP\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "7X7ktN5bGuQX"
   },
   "source": [
    "Create and print the final table as Pandas dataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 287
    },
    "id": "RUnmEZOKGuQX",
    "outputId": "3ab8a262-070e-407f-ced5-f1baf68fc2cf"
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data=table, columns=headers)\n",
    "html = dataframe_to_html(df)\n",
    "html"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "run-simulations-and-extract-properties.ipynb",
   "provenance": []
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}