{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Reactions\n", "In this example, we will initialize a reaction that represents the formation of water from its elements (i.e. H2 + 0.5O2 -> H2O) and calculate reaction properties. Note that in this example, we will make arbitrary transition state species and BEP relationships so the values calculated are not representative of real-world reactions.\n", "\n", "## Topics Covered\n", "- Read a thermdat file and convert it to a dictionary of ``Nasa`` objects\n", "- Initialize a ``Reaction`` object manually and from strings\n", "- Add a BEP relationship to a ``Reaction`` object\n", "- Calculate thermodynamic and kinetic properties using the ``Reaction`` object\n", "- Save the ``Reaction`` object as a ``JSON`` file\n", "\n", "## Files Required\n", "- [thermdat](thermdat) Thermdat file used to initialize ``Nasa`` species" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize Species Used For Reaction\n", "First, we need to describe our species as pMuTT objects. For this example, we will be importing the thermdat from the [combustion database by Berkeley](http://combustion.berkeley.edu/gri_mech/version30/files30/thermo30.dat). We will store the species in a dictionary for code clarity later on." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'H2': ,\n", " 'H2O': ,\n", " 'O2': }\n" ] } ], "source": [ "from pprint import pprint\n", "from pmutt.io.thermdat import read_thermdat\n", "from pmutt import pmutt_list_to_dict\n", "\n", "# The output will be a list\n", "species_list = read_thermdat(filename='thermdat')\n", "\n", "# This function converts the list to a dict for easier usage downstream\n", "species_dict = pmutt_list_to_dict(pmutt_list=species_list, key='name')\n", "\n", "# (Optional) Print the species_dict to see what's in it\n", "pprint(species_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To calculate transition state properties, we will need to represent the transition state species as a pMuTT object. For this example, we will create a new ``Nasa`` object based on the H2O entry but modify the a6 parameter arbitrarily to give it a higher enthalpy." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'H2': ,\n", " 'H2O': ,\n", " 'H2O_TS': ,\n", " 'O2': }\n" ] } ], "source": [ "from copy import deepcopy\n", "\n", "# Make a copy so we don't edit the original H2O\n", "H2O_TS = deepcopy(species_dict['H2O'])\n", "\n", "# Change name to differentiate it\n", "H2O_TS.name = 'H2O_TS'\n", "\n", "# Increase the H/RT value\n", "H2O_TS.a_low[5] += 50.\n", "H2O_TS.a_high[5] += 50.\n", "\n", "# Add it to the dictionary\n", "species_dict['H2O_TS'] = H2O_TS\n", "\n", "# (Optional) Print the new dictionary to see the new entry\n", "pprint(species_dict)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize Reaction Manually\n", "Let us initialize the reaction manually. You will have to feed the reactants, transition states, products and their stoichiometries." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating Reaction object manually: H2+0.50O2=H2O_TS=H2O\n" ] } ], "source": [ "from pmutt.reaction import Reaction\n", "\n", "rxn = Reaction(reactants=[species_dict['H2'], species_dict['O2']], reactants_stoich=[1., 0.5],\n", " products =[species_dict['H2O']], products_stoich=[1.],\n", " transition_state=species_dict['H2O_TS'], transition_state_stoich=[1.])\n", "# (Optional) Converting a Reaction object to a string will give its stoichiometric formula\n", "print('Creating Reaction object manually: {}'.format(rxn))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize Reaction Using Strings\n", "Initializing manually is cumbersome and prone to error. Instead, we can use ``.from_string()`` to initialize the reaction more easily." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Creating Reaction object using default string notation: H2+0.50O2=H2O_TS=H2O\n", "Creating Reaction object using custom string notation: H2+0.50O2=H2O_TS=H2O\n" ] } ], "source": [ "rxn = Reaction.from_string(reaction_str='H2 + 0.5O2 = H2O_TS = H2O', species=species_dict)\n", "\n", "# See that you get the same stoichiometry as before\n", "print('Creating Reaction object using default string notation: {}'.format(rxn))\n", "\n", "# You can specify the notation for the reaction!\n", "rxn = Reaction.from_string(reaction_str='H2 ++ 0.5O2 --> H2O_TS --> H2O', \n", " species=species_dict,\n", " species_delimiter='++',\n", " reaction_delimiter='-->')\n", "# When reprinting it, it will converts it to the standard notation\n", "print('Creating Reaction object using custom string notation: {}'.format(rxn))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculate Thermodynamic Reaction Properties\n", "With the reaction object specified, we can now calculate reaction properties. Let us calculate the standard formation enthalpy and standard entropy." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Calculated using Reaction object:\n", "Delta H: -241.82304908408534 kJ/mol\n", "Delta S: -44.42136350776074 J/mol/K\n", "\n", "\n", "Expected result from NIST:\n", "Delta H: -241.826 kJ/mol\n", "Delta S: -44.416 J/mol/K\n" ] } ], "source": [ "from pmutt import constants as c\n", "\n", "T = 298.\n", "dH_298 = rxn.get_delta_H(T=T, units='kJ/mol')\n", "dS_298 = rxn.get_delta_S(T=T, units='J/mol/K')\n", "\n", "print('Calculated using Reaction object:')\n", "print('Delta H: {} kJ/mol'.format(dH_298))\n", "print('Delta S: {} J/mol/K'.format(dS_298))\n", "print('\\n')\n", "print('Expected result from NIST:')\n", "print('Delta H: -241.826 kJ/mol')\n", "print('Delta S: {} J/mol/K'.format(188.84-130.68-0.5*205.152))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A ``Reaction`` object can only calculate properties its reactants, transition state, and products can calculate. In this example, we represented our species as ``Nasa`` objects so we can only calculate change in heat capacity (ΔCp), enthalpy (ΔH), entropy (ΔS), and Gibbs energy (ΔG).\n", "\n", "If you used ``StatMech`` objects instead of ``Nasa`` objects, you can calculate a wider variety of properties." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculate Kinetic Reaction Properties\n", "Since we added a transition state to the ``Reaction`` object, we can calculate kinetic properties such as the activation energy (Ea) and the pre-exponential factor (A). Since we arbitrarily made a transition state species, take the printed value with a grain of salt" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Forward properties\n", "Enthalpy of activation: -241.82 kJ/mol\n", "Activation Energy: -241.41 kJ/mol\n", "Pre-exponential factor: 2.970e+10 1/s\n", "\n", "\n", "Reverse properties\n", "Enthalpy of activation: 241.82 kJ/mol\n", "Activation Energy: 0.42 kJ/mol\n", "Pre-exponential factor: 6.209e+12 1/s\n" ] } ], "source": [ "# Forward direction properties (i.e. reactants to transition state)\n", "H_TS = rxn.get_delta_H(T=T, activation=True, units='kJ/mol')\n", "Ea = rxn.get_E_act(T=T, units='kJ/mol')\n", "A = rxn.get_A(T=T)\n", "\n", "# Take these values with a grain of salt since we arbitrarily \n", "# specified our transition state\n", "print('Forward properties')\n", "print('Enthalpy of activation: {:.2f} kJ/mol'.format(H_TS))\n", "print('Activation Energy: {:.2f} kJ/mol'.format(Ea))\n", "print('Pre-exponential factor: {:.3e} 1/s'.format(A))\n", "print('\\n')\n", "# Reverse direction properties (i.e. products to transition state)\n", "H_TS_rev = rxn.get_delta_H(T=T, activation=True, rev=True, units='kJ/mol')\n", "Ea_rev = rxn.get_E_act(T=T, rev=True, units='kJ/mol')\n", "A_rev = rxn.get_A(T=T, rev=True)\n", "\n", "print('Reverse properties')\n", "print('Enthalpy of activation: {:.2f} kJ/mol'.format(H_TS_rev))\n", "print('Activation Energy: {:.2f} kJ/mol'.format(Ea_rev))\n", "print('Pre-exponential factor: {:.3e} 1/s'.format(A_rev))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculating Activation Energy Using BEP Relationships\n", "A ``BEP`` object can be used instead of a transition state species to calculate activation energies. Again, we will arbitrarily create a BEP relationship." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "BEP: 370.04 kJ/mol\n" ] } ], "source": [ "from pmutt.reaction.bep import BEP\n", "\n", "species_dict['BEP'] = BEP(name='BEP', slope=0.2, intercept=100., descriptor='delta_H')\n", "rxn = Reaction.from_string(reaction_str='H2 + 0.5O2 = BEP = H2O', species=species_dict)\n", "Ea_BEP = rxn.get_E_act(T=T, units='kJ/mol')\n", "\n", "print('BEP: {:.2f} kJ/mol'.format(Ea_BEP))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Saving and Loading our Reaction as JSON\n", "Similarly to pMuTT objects, ``Reaction`` objects can be saved to and read from JSON format." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H2+0.50O2=BEP=H2O\n", "Delta H: -241.82 kJ/mol\n", "Activation Energy: 370.04 kJ/mol\n" ] } ], "source": [ "import json\n", "from pmutt.io.json import pmuttEncoder, json_to_pmutt\n", "\n", "# Saving\n", "with open('reaction.json', 'w') as f_ptr:\n", " json.dump(rxn, f_ptr, cls=pmuttEncoder, indent=True)\n", " \n", "# Loading\n", "with open('reaction.json', 'r') as f_ptr:\n", " rxn_io = json.load(f_ptr, object_hook=json_to_pmutt)\n", "\n", "# (Optional) Print your rxn to show it was loaded correctly\n", "dH_298_io = rxn_io.get_delta_H(T=T, units='kJ/mol')\n", "Ea_io = rxn_io.get_E_act(T=T, units='kJ/mol')\n", "\n", "print(rxn_io)\n", "print('Delta H: {:.2f} kJ/mol'.format(dH_298_io))\n", "print('Activation Energy: {:.2f} kJ/mol'.format(Ea_io))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is the resulting JSON file.\n", "```\n", "{\n", " \"class\": \"\",\n", " \"reactants\": [\n", " {\n", " \"class\": \"\",\n", " \"type\": \"nasa\",\n", " \"name\": \"H2\",\n", " \"phase\": \"G\",\n", " \"elements\": {\n", " \"H\": 2\n", " },\n", " \"notes\": \"TPIS78\",\n", " \"smiles\": null,\n", " \"model\": null,\n", " \"misc_models\": [\n", " {\n", " \"class\": \"\"\n", " }\n", " ],\n", " \"a_low\": [\n", " 2.34433112,\n", " 0.00798052075,\n", " -1.9478151e-05,\n", " 2.01572094e-08,\n", " -7.37611761e-12,\n", " -917.935173,\n", " 0.683010238\n", " ],\n", " \"a_high\": [\n", " 3.3372792,\n", " -4.94024731e-05,\n", " 4.99456778e-07,\n", " -1.79566394e-10,\n", " 2.00255376e-14,\n", " -950.158922,\n", " -3.20502331\n", " ],\n", " \"T_low\": 200.0,\n", " \"T_mid\": 1000.0,\n", " \"T_high\": 3500.0,\n", " \"cat_site\": null,\n", " \"n_sites\": null\n", " },\n", " {\n", " \"class\": \"\",\n", " \"type\": \"nasa\",\n", " \"name\": \"O2\",\n", " \"phase\": \"G\",\n", " \"elements\": {\n", " \"O\": 2\n", " },\n", " \"notes\": \"TPIS89\",\n", " \"smiles\": null,\n", " \"model\": null,\n", " \"misc_models\": [\n", " {\n", " \"class\": \"\"\n", " }\n", " ],\n", " \"a_low\": [\n", " 3.78245636,\n", " -0.00299673416,\n", " 9.84730201e-06,\n", " -9.68129509e-09,\n", " 3.24372837e-12,\n", " -1063.94356,\n", " 3.65767573\n", " ],\n", " \"a_high\": [\n", " 3.28253784,\n", " 0.00148308754,\n", " -7.57966669e-07,\n", " 2.09470555e-10,\n", " -2.16717794e-14,\n", " -1088.45772,\n", " 5.45323129\n", " ],\n", " \"T_low\": 200.0,\n", " \"T_mid\": 1000.0,\n", " \"T_high\": 3500.0,\n", " \"cat_site\": null,\n", " \"n_sites\": null\n", " }\n", " ],\n", " \"reactants_stoich\": [\n", " 1.0,\n", " 0.5\n", " ],\n", " \"products\": [\n", " {\n", " \"class\": \"\",\n", " \"type\": \"nasa\",\n", " \"name\": \"H2O\",\n", " \"phase\": \"G\",\n", " \"elements\": {\n", " \"H\": 2,\n", " \"O\": 1\n", " },\n", " \"notes\": \"L 8/89\",\n", " \"smiles\": null,\n", " \"model\": null,\n", " \"misc_models\": [\n", " {\n", " \"class\": \"\"\n", " }\n", " ],\n", " \"a_low\": [\n", " 4.19864056,\n", " -0.0020364341,\n", " 6.52040211e-06,\n", " -5.48797062e-09,\n", " 1.77197817e-12,\n", " -30293.7267,\n", " -0.849032208\n", " ],\n", " \"a_high\": [\n", " 3.03399249,\n", " 0.00217691804,\n", " -1.64072518e-07,\n", " -9.7041987e-11,\n", " 1.68200992e-14,\n", " -30004.2971,\n", " 4.9667701\n", " ],\n", " \"T_low\": 200.0,\n", " \"T_mid\": 1000.0,\n", " \"T_high\": 3500.0,\n", " \"cat_site\": null,\n", " \"n_sites\": null\n", " }\n", " ],\n", " \"products_stoich\": [\n", " 1.0\n", " ],\n", " \"transition_state\": [\n", " {\n", " \"class\": \"\",\n", " \"name\": \"BEP\",\n", " \"slope\": 0.2,\n", " \"intercept\": 100.0,\n", " \"descriptor\": \"delta_H\",\n", " \"notes\": null\n", " }\n", " ],\n", " \"transition_state_stoich\": [\n", " 1.0\n", " ]\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting Reaction Coordinate Diagrams\n", "\n", "The ``pmutt.reaction.Reactions.plot_coordinate_diagram`` allows users to plot reaction coordinate diagrams in a semi-automated way. For this example, we will use the synthesis of NH3 on Ru. The thermdat file was taken from the [NH3 MATLAB Microkinetic Model available on Github][0].\n", "\n", "[0]: https://github.com/VlachosGroup/NH3-Matlab-Microkinetic-Model" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import os\n", "from pathlib import Path\n", "from matplotlib import pyplot as plt\n", "from pmutt import pmutt_list_to_dict\n", "from pmutt.reaction import Reaction, Reactions\n", "from pmutt.io.thermdat import read_thermdat\n", "\n", "# Find the location of Jupyter notebook\n", "# Note that normally Python scripts have a __file__ variable but Jupyter notebook doesn't.\n", "# Using pathlib can overcome this limiation\n", "notebook_folder = Path().resolve()\n", "\n", "'''Read the thermdat file and convert it to a dictionary'''\n", "NH3_species_list = read_thermdat(os.path.join(notebook_folder, 'thermdat_NH3'))\n", "NH3_species = pmutt_list_to_dict(NH3_species_list)\n", "\n", "'''Initialize the reaction'''\n", "rxns = Reactions(reactions=[\n", " Reaction.from_string('0.5N2 + 1.5H2 = 0.5TS4_N2 + 1.5H2 = N(S1) + 1.5H2', \n", " NH3_species),\n", " Reaction.from_string('N(S1) + 1.5H2 = N(S1) + 3H(S1)', NH3_species),\n", " Reaction.from_string('N(S1) + 3H(S1) = TS3_NH + 2H(S1) = NH(S1) + 2H(S1)', \n", " NH3_species),\n", " Reaction.from_string('NH(S1) + 2H(S1) = TS2_NH2 + H(S1) = NH2(S1) + H(S1)',\n", " NH3_species),\n", " Reaction.from_string('NH2(S1) + H(S1) = TS1_NH3 = NH3(S1)', NH3_species),\n", " Reaction.from_string('NH3(S1) = NH3', NH3_species)])\n", "\n", "'''Plot the reaction coordinate diagram'''\n", "# Enthalpy coordinate diagram\n", "fig1, ax1 = rxns.plot_coordinate_diagram(method_name='get_H', units='eV',\n", " T=300.)\n", "# Gibbs energy coordinate diagram on the same plot\n", "fig1, ax1 = rxns.plot_coordinate_diagram(method_name='get_G', units='eV',\n", " T=300., figure=fig1, axes=ax1)\n", "\n", "'''Adjust plot settings'''\n", "ax1.legend(['Enthalpy (H)', 'Gibbs Energy (G)'])\n", "ax1.set_ylabel('Energy (eV)')\n", "fig1.set_size_inches(12, 10)\n", "fig1.dpi = 150\n", "plt.show()" ] }, { "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.6" } }, "nbformat": 4, "nbformat_minor": 2 }