Untitled-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import subprocess\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "# import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from Resources.FDS.PeriodicTableFDS653 import PeriodicTable as PT\n",
    "from Resources.FDS.ChemicalSpeciesFDS653 import ChemicalSpecies as CS\n",
    "\n",
    "# sns.set(style=\"darkgrid\")\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0107 1.00794 15.9994 14.0067 35.453\n"
     ]
    }
   ],
   "source": [
    "# define atomic weights\n",
    "W_C = PT['C'][1]\n",
    "W_H = PT['H'][1]\n",
    "W_O = PT['O'][1]\n",
    "W_N = PT['N'][1]\n",
    "W_Cl = PT['Cl'][1]\n",
    "print(W_C, W_H, W_O, W_N, W_Cl)\n",
    "\n",
    "# Define hydrogen atomic fraction in soot.\n",
    "X_H = 0.1\n",
    "\n",
    "\n",
    "# Define yields.\n",
    "# All produced species treaded as yield.\n",
    "# Assumed Cl is completely consumed by HCl.\n",
    "# Remaining C, H, N, O produce CO2, H2O and N2.\n",
    "# y_CO = 0.22\n",
    "# y_HCl = 0.025204\n",
    "# y_HCN = 0.016\n",
    "# y_C7H5NO = 0.0003\n",
    "# y_C7H5N = 0.0018\n",
    "# y_Soot = 0.09\n",
    "# y_NO = 0.01\n",
    "# y_Cl2 = 0.014398\n",
    "\n",
    "# y_CO = 0.16\n",
    "# y_HCl = 0.025\n",
    "# y_HCN = 0.012\n",
    "# y_C7H5NO = 0.00005\n",
    "# y_C7H5N = 0.00036\n",
    "# y_Soot = 0.153\n",
    "# y_NO = 0.007\n",
    "# y_Cl2 = 0.014\n",
    "\n",
    "def reaction_coefficient(fuel_mol, component_mol\n",
    "                         , component_yield):\n",
    "    rc = fuel_mol/component_mol * component_yield\n",
    "    return rc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fuel mol weight: 2.01588 g/mol\n"
     ]
    }
   ],
   "source": [
    "fuel_molecule = [['H', 2.0]]\n",
    "\n",
    "mol_weight_fuel = 0\n",
    "for element in fuel_molecule:\n",
    "    mol_weight_fuel += PT[element[0]][1] * element[1]\n",
    "\n",
    "print('Fuel mol weight: {} g/mol'.format(mol_weight_fuel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element matrix:\n",
      "[[2. 0. 2. 0.]\n",
      " [0. 2. 1. 0.]\n",
      " [0. 0. 0. 2.]]\n"
     ]
    }
   ],
   "source": [
    "# define primitive species\n",
    "#\n",
    "# CO2, CO, HCl, HCN, C7H5NO, C7H5N,  \n",
    "# NO, CC, H2O, Cl2, N2, Soot\n",
    "\n",
    "i_H2     = 0\n",
    "i_O2     = 1\n",
    "i_H2O    = 2\n",
    "i_N2     = 3\n",
    "\n",
    "\n",
    "n_spec_list = [i_H2, i_O2, i_H2O, i_N2]\n",
    "n_species = len(n_spec_list)\n",
    "    \n",
    "chem_name_list = [\"HYDROGEN\", \"OXYGEN\", \"WATER VAPOR\", \"NITROGEN\"]\n",
    "\n",
    "# define the element matrix (number of atoms [rows] for each primitive species\n",
    "# [columns])\n",
    "#                0  1  2  3  \n",
    "E = np.array([[2.0, 0, 2, 0 ],  # H\n",
    "              [0.0, 2, 1, 0 ],  # O\n",
    "              [0.0, 0, 0, 2 ]])  # N\n",
    "\n",
    "print('Element matrix:')\n",
    "print(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.],\n",
       "       [0.],\n",
       "       [0.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(chem_name_list)\n",
    "E[:, [i_H2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volume fractions of FUEL\n",
      "[1. 0. 0. 0.] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# define volume fractions of fuel mixture (assumed known)\n",
    "vol_fuel = np.zeros((n_species))\n",
    "vol_fuel[i_H2]        = 100.0\n",
    "vol_fuel = vol_fuel/np.sum(vol_fuel)\n",
    "print('Volume fractions of FUEL')\n",
    "print(vol_fuel, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primitive species molecular weights:\n",
      "[ 2.01588 31.9988  18.01528 28.0134 ]\n"
     ]
    }
   ],
   "source": [
    "#primitive species molecular weights\n",
    "A = np.array([W_H, W_O, W_N])\n",
    "W = np.dot(E.T, A)\n",
    "\n",
    "print('Primitive species molecular weights:')\n",
    "print(W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define volume fraction of air.\n",
    "vol_frac_air = np.zeros(n_species)\n",
    "\n",
    "# vol_frac_air[i_O2] = 1 / 4.76\n",
    "# vol_frac_air[i_N2] = 3.76 / 4.76\n",
    "vol_frac_air[i_O2] = 0.21\n",
    "vol_frac_air[i_N2] = 0.79\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Molecular weight of AIR\n",
      "28.76577365168055 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "W_1 = 1./np.sum(vol_frac_air/W)\n",
    "print('Molecular weight of AIR')\n",
    "print(W_1, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reac_coeff = np.zeros(n_species)\n",
    "\n",
    "\n",
    "\n",
    "# y_HCN = 0.016\n",
    "# y_C7H5NO = 0.0003\n",
    "# y_C7H5N = 0.0018\n",
    "# y_NO = 0.01\n",
    "\n",
    "# compute what we know so far\n",
    "# Basically consumption known from yields.\n",
    "# reac_coeff[i_CO]   = reaction_coefficient(mol_weight_fuel, \n",
    "#                                           W[i_CO], y_CO)\n",
    "# reac_coeff[i_Soot] = reaction_coefficient(mol_weight_fuel, \n",
    "#                                           W[i_Soot], y_Soot)\n",
    "# reac_coeff[i_HCl] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_HCl], y_HCl)\n",
    "# reac_coeff[i_HCN] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_HCN], y_HCN)\n",
    "# reac_coeff[i_C7H5NO] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_C7H5NO], y_C7H5NO)\n",
    "# reac_coeff[i_C7H5N] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_C7H5N], y_C7H5N)\n",
    "# reac_coeff[i_NO] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_NO], y_NO)\n",
    "# reac_coeff[i_Cl2] = reaction_coefficient(mol_weight_fuel,\n",
    "#                                         W[i_Cl2], y_Cl2)\n",
    "\n",
    "reac_coeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "[2. 0. 0.] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# linear system right hand side\n",
    "b = np.dot(E, vol_fuel - reac_coeff)\n",
    "print('b')\n",
    "print(b, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "[[0.   2.   0.  ]\n",
      " [0.42 1.   0.  ]\n",
      " [1.58 0.   2.  ]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# matrix\n",
    "L = np.array([np.dot(E, vol_frac_air),\n",
    "              E[:, i_H2O],\n",
    "              E[:, i_N2]]).T\n",
    "print('L')\n",
    "print(L, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "[-2.38095238  1.          1.88095238] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# % solve the system\n",
    "x = np.linalg.solve(L, b)\n",
    "print('x')\n",
    "print(x, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "nu_1              = x[0]  # background stoichiometric coefficient\n",
    "reac_coeff[i_H2O] = x[1]\n",
    "reac_coeff[i_N2]  = x[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.        , 0.34710744, 0.65289256])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nu_2 = -1        # fuel stoichiometric coefficient\n",
    "nu_3 = sum(reac_coeff)  # prod stoichiometric coefficient\n",
    "\n",
    "reac_coeff = reac_coeff/nu_3  # normalized product volume fractions\n",
    "reac_coeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mass balance\n",
      "1.4210854715202004e-14 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# check mass balance (should be 0)\n",
    "print('Mass balance')\n",
    "print(nu_1*np.sum(vol_frac_air*W) + nu_2*np.sum(vol_fuel*W) + nu_3*np.sum(reac_coeff*W), '\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# String templates of species input lines.\n",
    "SPECTEMPLUMP = \"&SPEC ID='{}',\"\n",
    "SPECID = \"SPEC_ID({})='{}', \"\n",
    "SPECVOLFRAC = \"VOLUME_FRACTION({})={}, \"\n",
    "SPECMASSFRAC = \", MASS_FRACTION({})={}\"\n",
    "SPECLUMPCOMP = \", LUMPED_COMPONENT_ONLY=.{}.\"\n",
    "SPECBACKGROUND = \", BACKGROUND=.{}.\"\n",
    "\n",
    "# REACTEMPLATE = \"&REAC FUEL='label', SPEC_ID_NU='fuel','air','PRODUCTS',\" + \\\n",
    "#            \"      NU=nufuel,nuair,nuprod, HEAT_OF_COMBUSTION=hoc /\"\n",
    "\n",
    "# String templates for reaction parameters.\n",
    "REACTEMP = \"&REAC FUEL='{}'{}{} /\"\n",
    "REACSPECIDNU = \", SPEC_ID_NU='{}','{}','{}', NU=-{},-{},{}\"\n",
    "REACHOC = \", HEAT_OF_COMBUSTION={}\"\n",
    "\n",
    "FORMTEMP = \"C{}H{}O{}N{}\"\n",
    "FORMTEMP2 = \"H{}O{}N{}\"\n",
    "# String template for species.\n",
    "SPECIDTEMP = \"&SPEC ID='{}', LUMPED_COMPONENT_ONLY=.{}. /\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"&SPEC ID='HYDROGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='OXYGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='WATER VAPOR', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='NITROGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\"]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spec_list = []\n",
    "for i in range(len(chem_name_list)):\n",
    "    ml = E[:, [n_spec_list[i]]].tolist()\n",
    "    nf = FORMTEMP2.format(ml[0][0], ml[1][0], ml[2][0])#, ml[3][0])\n",
    "    new = SPECIDTEMP.format(chem_name_list[i],\"TRUE\", nf)\n",
    "    spec_list.append(new)\n",
    "\n",
    "    \n",
    "spec_list\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# spec_comps = []\n",
    "\n",
    "spec_list.append(SPECTEMPLUMP.format(\"PRODUCTS\"))\n",
    "\n",
    "counter = 1\n",
    "for i in range(len(reac_coeff)):\n",
    "    if reac_coeff.tolist()[i] == 0.0:\n",
    "        continue\n",
    "    sp_id = SPECID.format(counter, chem_name_list[i])\n",
    "    v_frac = SPECVOLFRAC.format(counter, reac_coeff.tolist()[i])\n",
    "    \n",
    "    spec_list.append(\"      {}{}\".format(sp_id, v_frac))\n",
    "    \n",
    "    counter += 1\n",
    "\n",
    "spec_list[-1] = spec_list[-1][:-2]+\" /\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"&SPEC ID='HYDROGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='OXYGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='WATER VAPOR', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='NITROGEN', LUMPED_COMPONENT_ONLY=.TRUE. /\",\n",
       " \"&SPEC ID='PRODUCTS',\",\n",
       " \"      SPEC_ID(1)='WATER VAPOR', VOLUME_FRACTION(1)=0.3471074380165289, \",\n",
       " \"      SPEC_ID(2)='NITROGEN', VOLUME_FRACTION(2)=0.652892561983471 /\"]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spec_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 0.0, 0.3471074380165289, 0.652892561983471]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reac_coeff.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = \"REAC.txt\"\n",
    "with open(fn, \"w\") as newfile:\n",
    "    for i in spec_list:\n",
    "        newfile.write(i+\"\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spec_list = []\n",
    "spec_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}