Chapter08_Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ce2d6e30",
   "metadata": {},
   "source": [
    "# Chapter 8: Calculation of Molecular Properties"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "295a0f8f",
   "metadata": {},
   "source": [
    "## 8.2. Calculation of Potential Energy of Reaction Intermediates"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a326b8f",
   "metadata": {},
   "source": [
    "Computational methods allows the calculation of potential energy of reaction intermediates such as cation, anion, and free radical."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36860dfb",
   "metadata": {},
   "source": [
    "### 8.2.1. Calculation of Potential Energy of Cations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1798eec",
   "metadata": {},
   "source": [
    "In the following section, we will calculate the potential energies of different allyic cations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dc680d6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem, Draw\n",
    "from utils import View3DModel\n",
    "import psi4\n",
    "import py3Dmol\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f38307c4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create the cation\n",
    "cation1 = Chem.MolFromSmiles('[CH3+]')\n",
    "cation2 = Chem.MolFromSmiles('[CH2+](C)')\n",
    "cation3 = Chem.MolFromSmiles('[CH+](C)(C)')\n",
    "cation4 = Chem.MolFromSmiles('[C+](C)(C)(C)')\n",
    "cation5 = Chem.MolFromSmiles('[C+](C1=CC=CC=C1)(C)(C)')\n",
    "cations = [cation1, cation2, cation3, cation4, cation5]\n",
    "\n",
    "Draw.MolsToGridImage(cations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d732bf8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create the molecules\n",
    "mol1 = Chem.MolFromSmiles('C')\n",
    "mol2 = Chem.MolFromSmiles('CC')\n",
    "mol3 = Chem.MolFromSmiles('C(C)(C)')\n",
    "mol4 = Chem.MolFromSmiles('C(C)(C)(C)')\n",
    "mol5 = Chem.MolFromSmiles('C(C1=CC=CC=C1)(C)C')\n",
    "mols = [mol1, mol2, mol3, mol4, mol5]\n",
    "\n",
    "Draw.MolsToGridImage(mols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff399c71",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the number of threads and memory limit\n",
    "psi4.set_num_threads(16)\n",
    "psi4.set_memory(16*1024*1024*1024) # 16 GB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c248c5fa",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set calculation options\n",
    "psi4.set_options({\n",
    "    'BASIS': '6-31++G**',\n",
    "    'SCF_TYPE': 'DF',\n",
    "    'REFERENCE': 'RHF'\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2bee025",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define a function to generate xyz string with charge and multiplicity\n",
    "def generate_xyz_string(mol, charge, multiplicity):\n",
    "    # Get atom information\n",
    "    atoms = mol.GetAtoms()\n",
    "    xyz_lines = []\n",
    "    for atom in atoms:\n",
    "        pos = mol.GetConformer().GetAtomPosition(atom.GetIdx())\n",
    "        xyz_lines.append(f\"{atom.GetSymbol()} {pos.x} {pos.y} {pos.z}\")\n",
    "\n",
    "    # Construct the XYZ string\n",
    "    xyz_string = f\"{charge} {multiplicity}\\n\" + \"\\n\".join(xyz_lines)\n",
    "    return xyz_string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a06fe4a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cation_energies = []\n",
    "cation_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all cations\n",
    "progress_bar = tqdm(cations)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    charge = 1  # For cation\n",
    "    multiplicity = 1  # Singlet state\n",
    "    xyz_string = generate_xyz_string(mol, charge, multiplicity)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    cation_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    cation_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c43a1fc2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mol_energies = []\n",
    "mol_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all molecules\n",
    "progress_bar = tqdm(mols)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    xyz_string = Chem.MolToXYZBlock(mol)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    mol_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    mol_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ea76d68",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Calculate the energy differences between the cations and the molecules\n",
    "cation_energies = np.array(cation_energies)\n",
    "mol_energies = np.array(mol_energies)\n",
    "energy_diff = cation_energies - mol_energies\n",
    "\n",
    "# Use methyl free radical as the reference\n",
    "energy_diff = energy_diff - energy_diff[0]\n",
    "\n",
    "# Plot the energy differences\n",
    "x = range(len(energy_diff))\n",
    "plt.bar(x, energy_diff)\n",
    "plt.xlabel('Cation')\n",
    "plt.ylabel('Energy difference (kcal/mol)')\n",
    "plt.axhline(0, color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb670237",
   "metadata": {},
   "source": [
    "### 8.2.2. Calculation of Potential Energy of Anion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3af57e4f",
   "metadata": {},
   "source": [
    "In the following section, we will calculate the potential energies of different benzoic acids and benzoate anions in order to compare there acidity/basicity:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74575da4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem, Draw\n",
    "from utils import View3DModel, WriteXYZString # same as generate_xyz_string() function above\n",
    "import psi4\n",
    "import py3Dmol\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74fcc51e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create the core molecules\n",
    "core_acid_mol = Chem.MolFromSmiles('c1cc(C(=O)O)ccc1*')\n",
    "core_base_mol = Chem.MolFromSmiles('c1cc(C(=O)[O-])ccc1*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4507990",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Draw.MolsToGridImage([core_acid_mol, core_base_mol])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2413cf04",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define substituents\n",
    "substituents = ['[H]', 'C', 'Cl', 'O', 'C(=O)C']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e492c80",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Generate acids band bases\n",
    "acids = []\n",
    "bases = []\n",
    "\n",
    "for substituent in substituents:\n",
    "    # Create a copy of the core molecules\n",
    "    core_acid_mol_copy = Chem.Mol(core_acid_mol)\n",
    "    core_base_mol_copy = Chem.Mol(core_base_mol)\n",
    "\n",
    "    # Replace a hydrogen atom with the substituent\n",
    "    subst_mol = Chem.MolFromSmiles(substituent)\n",
    "    subst_acid_mol_smiles = Chem.MolToSmiles(Chem.rdmolops.ReplaceSubstructs(core_acid_mol_copy, Chem.MolFromSmarts('[#0]'), subst_mol)[0])\n",
    "    subst_base_mol_smiles = Chem.MolToSmiles(Chem.rdmolops.ReplaceSubstructs(core_base_mol_copy, Chem.MolFromSmarts('[#0]'), subst_mol)[0])\n",
    "    acids.append(Chem.MolFromSmiles(subst_acid_mol_smiles))\n",
    "    bases.append(Chem.MolFromSmiles(subst_base_mol_smiles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ceb1060a",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "Draw.MolsToGridImage(acids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3d6d9b4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "Draw.MolsToGridImage(bases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7351867",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the number of threads and set memory limit\n",
    "psi4.set_num_threads(32)\n",
    "psi4.set_memory(16*1024*1024*1024) # 16 GB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c93f6335",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set calculation options\n",
    "psi4.set_options({\n",
    "    'BASIS': '6-31G*',\n",
    "    'SCF_TYPE': 'DF',\n",
    "    'REFERENCE': 'RHF'\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "538cdfdb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "acid_energies = []\n",
    "acid_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all acids\n",
    "progress_bar = tqdm(acids)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    xyz_string = Chem.MolToXYZBlock(mol)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    acid_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    acid_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da890e13",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "base_energies = []\n",
    "base_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all bases\n",
    "progress_bar = tqdm(bases)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    charge = -1  # For anion\n",
    "    multiplicity = 1  # Singlet state\n",
    "    xyz_string = WriteXYZString(mol, charge, multiplicity)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    base_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    base_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a000d3cc",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Calculate the energy differences between the acids and the bases\n",
    "acid_energies = np.array(acid_energies)\n",
    "base_energies = np.array(base_energies)\n",
    "energy_diff = base_energies - acid_energies\n",
    "\n",
    "# Use benzoic acid as the reference\n",
    "energy_diff = energy_diff - energy_diff[0]\n",
    "\n",
    "# Plot the energy differences\n",
    "x = range(len(energy_diff))\n",
    "plt.bar(x, energy_diff)\n",
    "plt.xlabel('Compound')\n",
    "plt.ylabel('Energy difference (kcal/mol)')\n",
    "plt.axhline(0, color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b03424c1",
   "metadata": {},
   "source": [
    "### 8.2.3. Calculation of Potential Energy of Free Radicals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae9e3d3f",
   "metadata": {},
   "source": [
    "In the following section, we will calculate the potential energies of different free radical and compare their stability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5130f08e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem, Draw\n",
    "from utils import View3DModel, WriteXYZString\n",
    "import psi4\n",
    "import py3Dmol\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24b4b087",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create the free radicals\n",
    "radical1 = Chem.MolFromSmiles('[CH3]')\n",
    "radical2 = Chem.MolFromSmiles('[CH2](C)')\n",
    "radical3 = Chem.MolFromSmiles('[CH](C)(C)')\n",
    "radical4 = Chem.MolFromSmiles('[C](C)(C)(C)')\n",
    "radical5 = Chem.MolFromSmiles('[C](C1=CC=CC=C1)(C)(C)')\n",
    "radicals = [radical1, radical2, radical3, radical4, radical5]\n",
    "\n",
    "Draw.MolsToGridImage(radicals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "467eb4dd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create the molecules\n",
    "mol1 = Chem.MolFromSmiles('C')\n",
    "mol2 = Chem.MolFromSmiles('CC')\n",
    "mol3 = Chem.MolFromSmiles('C(C)(C)')\n",
    "mol4 = Chem.MolFromSmiles('C(C)(C)(C)')\n",
    "mol5 = Chem.MolFromSmiles('C(C1=CC=CC=C1)(C)C')\n",
    "mols = [mol1, mol2, mol3, mol4, mol5]\n",
    "\n",
    "Draw.MolsToGridImage(mols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8b24c64",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the number of threads and set memory limit\n",
    "psi4.set_num_threads(8)\n",
    "psi4.set_memory(16*1024*1024*1024) # 16 GB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e248cf81",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set calculation options\n",
    "psi4.set_options({\n",
    "    'BASIS': '6-31++G**',\n",
    "    'SCF_TYPE': 'DF',\n",
    "    'REFERENCE': 'UHF' # Use UHF or ROHF for doublet state\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95ec4aff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "radical_energies = []\n",
    "radical_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all free radicals\n",
    "progress_bar = tqdm(radicals)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    charge = 0  # For free radical\n",
    "    multiplicity = 2  # Doublet state\n",
    "    xyz_string = WriteXYZString(mol, charge, multiplicity)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    radical_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    radical_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbd1c6f8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set calculation options\n",
    "psi4.set_options({\n",
    "    'REFERENCE': 'RHF' # Use RHF for singlet state\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edc27657",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mol_energies = []\n",
    "mol_wfns = []\n",
    "\n",
    "# Optimize the geometries and calculate the energies for all molecules\n",
    "progress_bar = tqdm(mols)\n",
    "for mol in progress_bar:\n",
    "    smiles = Chem.MolToSmiles(mol)\n",
    "    progress_bar.set_description(f'SMILES: {smiles}. Optimizing geometry...')\n",
    "    \n",
    "    # Prepare the molecule\n",
    "    mol = Chem.AddHs(mol)\n",
    "    AllChem.EmbedMolecule(mol)\n",
    "    AllChem.UFFOptimizeMolecule(mol, maxIters=200)\n",
    "    \n",
    "    # Write the geometry to XYZ string\n",
    "    xyz_string = Chem.MolToXYZBlock(mol)\n",
    "\n",
    "    # Get the psi4 geometry\n",
    "    geometry = psi4.geometry(xyz_string)\n",
    "    \n",
    "    # Run geometry optimization\n",
    "    max_iters = 500\n",
    "    energy, wfn = psi4.optimize('b3lyp', molecule=geometry, optking__geom_maxiter=max_iters, return_wfn=True)\n",
    "    mol_energies.append(energy * psi4.constants.hartree2kcalmol)\n",
    "    mol_wfns.append(wfn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc7513a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Calculate the energy differences between the free radicals and the molecules\n",
    "radical_energies = np.array(radical_energies)\n",
    "mol_energies = np.array(mol_energies)\n",
    "energy_diff = radical_energies - mol_energies\n",
    "\n",
    "# Use methyl free radical as the reference\n",
    "energy_diff = energy_diff - energy_diff[0]\n",
    "\n",
    "# Plot the energy differences\n",
    "x = range(len(energy_diff))\n",
    "plt.bar(x, energy_diff)\n",
    "plt.xlabel('Free radical')\n",
    "plt.ylabel('Energy difference (kcal/mol)')\n",
    "plt.axhline(0, color='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8170886c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  },
  "toc": {
   "base_numbering": "",
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Table of Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "203px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}