Optimization of ΔTmin.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing Requisite Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import interpolate\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prompting the user to enter Overall Heat Transfer Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your Overall Heat Transfer Coefficient (W/m^2.K): 125\n"
     ]
    }
   ],
   "source": [
    "U=float(input(\"Enter your Overall Heat Transfer Coefficient (W/m^2.K): \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "<li>The following cell takes input from the excel sheet and a 'for' loop is run over the range of Tmin from 1°C to 100°C with an interval of 1°C. </li> <br>\n",
    "<li>The Problem Table algorithm is generated for each value of Tmin. Based on that, Pinch Temperature, Minimum Heating Required, and Minimum Cooling Required is found out. </li> <br>\n",
    "<li>The following cell also generates Hot Composite Curve and Cold Composite Curve for each value of Tmin. </li> <br> <li>Interpolation is done to get corressponding values of Temperature and Enthalpy wherever slopes of either composite curves changes. </li> <br> <li> This gives us the end temperature points of hot streams and cold streams as well as the Enthalpy Difference. </li> <br> <li> By using LMTD method, we find the area required. Summation is done over all the intervals to get the Total Minimum Area Required. </li> </ol>    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_table=pd.read_excel('Input Sheet.xlsx')\n",
    "input_table[\"Stream Type\"]=np.where(input_table[\"Supply Temperture (°C)\"]>input_table[\"Target Temperature (°C)\"],\"HOT\",\"COLD\")\n",
    "input_table[\"Heat Capacity Flowrate (kW/K)\"]=round(input_table[\"Heat Load (kW)\"]/(input_table[\"Target Temperature (°C)\"]-input_table[\"Supply Temperture (°C)\"]),2)\n",
    "#Heat Capacity Flowrate values of all hot streams have been made negative. This convention will be used later to simplify calculations.\n",
    "index=[]\n",
    "for n in range(1,len(input_table)+1):\n",
    "    index.append(n)\n",
    "input_table[\"Stream Number\"]=index\n",
    "input_table=input_table.set_index('Stream Number')\n",
    "input_table=input_table.rename(columns={\"Supply Temperture (°C)\": \"Ts\", \"Target Temperature (°C)\": \"Tt\", \"Heat Capacity Flowrate (kW/K)\":\"FCp\"})\n",
    "hot_streams=input_table[input_table[\"Stream Type\"]==\"HOT\"]\n",
    "cold_streams=input_table[input_table[\"Stream Type\"]==\"COLD\"]\n",
    "Tmin=np.linspace(1,100,100)\n",
    "minimum_total_area_required_in_m2=[]\n",
    "minimum_hot_utility_required_in_kW=[]\n",
    "minimum_cold_utility_required_in_kW=[]\n",
    "pinch_temperature_in_degC=[]\n",
    "for tmin in Tmin:\n",
    "    temp_left=cold_streams[\"Ts\"].append(cold_streams[\"Tt\"]).append(round((hot_streams[\"Ts\"]-tmin),2)).append(round((hot_streams[\"Tt\"]-tmin),2)).sort_values(ascending=False) \n",
    "    temp_left=list(dict.fromkeys(temp_left)) #this will drop duplicates\n",
    "    temp_right=hot_streams[\"Ts\"].append(hot_streams[\"Tt\"]).append(round((cold_streams[\"Ts\"]+tmin),2)).append(round((cold_streams[\"Tt\"]+tmin),2)).sort_values(ascending=False) \n",
    "    temp_right=list(dict.fromkeys(temp_right)) #this will drop duplicates\n",
    "    problem_table=pd.DataFrame()\n",
    "    problem_table[\"Network\"]=[i for i in range(len(temp_right))]\n",
    "    problem_table[\"Network\"]=problem_table[\"Network\"].astype(str)\n",
    "    problem_table[\"Sub\"]=np.repeat(\"SN\",len(temp_right))\n",
    "    problem_table['Subnetwork'] = problem_table['Sub']+problem_table[\"Network\"]\n",
    "    problem_table=problem_table.drop([\"Sub\",\"Network\"],axis=1)\n",
    "    problem_table[\"Tleft\"]=temp_left\n",
    "    problem_table[\"Tright\"]=temp_right\n",
    "    streams_involved=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "    cold_streams_involved_1=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "    hot_streams_involved_1=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "    for i in range(len(problem_table)):\n",
    "        for j in range(len(cold_streams)):\n",
    "            cold_streams_involved=np.where(cold_streams.iloc[j][\"Ts\"]<=problem_table.iloc[i][\"Tleft\"]<cold_streams.iloc[j][\"Tt\"],cold_streams.iloc[j].name,0)\n",
    "            streams_involved[i][cold_streams_involved]=cold_streams_involved\n",
    "            cold_streams_involved_1[i][cold_streams_involved]=cold_streams_involved\n",
    "        for k in range(len(hot_streams)):\n",
    "            hot_streams_involved=np.where(hot_streams.iloc[k][\"Tt\"]<=problem_table.iloc[i][\"Tright\"]<hot_streams.iloc[k][\"Ts\"],hot_streams.iloc[k].name,0)\n",
    "            streams_involved[i][hot_streams_involved]=hot_streams_involved\n",
    "            hot_streams_involved_1[i][hot_streams_involved]=hot_streams_involved\n",
    "    problem_table[\"Streams Involved\"]=[streams_involved[i] for i in range(len(problem_table))] \n",
    "    difference=[0]\n",
    "    for i in range(1,len(problem_table)):\n",
    "        difference.append(problem_table[\"Tleft\"][i-1]-problem_table[\"Tleft\"][i])\n",
    "    problem_table[\"Temperature Difference\"]=difference\n",
    "    k=np.zeros(len(problem_table))\n",
    "    for i in range(len(problem_table)):\n",
    "        streams=np.extract(problem_table[\"Streams Involved\"][i]!=0, problem_table[\"Streams Involved\"][i]) \n",
    "        sum_1=0\n",
    "        n=len(streams)\n",
    "        for n in range(len(streams)):\n",
    "            sum_1=sum_1+input_table.loc[streams[n]][\"FCp\"] \n",
    "        k[i]=sum_1\n",
    "    problem_table[\"Summation of FCp\"]=k\n",
    "    problem_table[\"Deficit\"]=problem_table[\"Summation of FCp\"]*problem_table[\"Temperature Difference\"]\n",
    "    x=[-problem_table[\"Deficit\"].cumsum()[i-1] for i in range(1,len(problem_table))]\n",
    "    x=np.array(x)\n",
    "    y=[0]\n",
    "    y=np.array(y)\n",
    "    z=np.concatenate((y,x))\n",
    "    problem_table[\"Accumulated Input\"]=z \n",
    "    problem_table[\"Accumulated Output\"]=-problem_table[\"Deficit\"].cumsum() \n",
    "    problem_table[\"Heat Flows Input\"]=abs(problem_table[\"Accumulated Output\"].min())+problem_table[\"Accumulated Input\"] \n",
    "    problem_table[\"Heat Flows Output\"]=abs(problem_table[\"Accumulated Output\"].min())+problem_table[\"Accumulated Output\"]\n",
    "    pinch_temp=problem_table[problem_table[\"Heat Flows Output\"]==0.0][\"Tright\"]\n",
    "    pinch_temp=pinch_temp.values\n",
    "    pinch_temp=pinch_temp[0]\n",
    "    minimum_hot_utility=problem_table.iloc[0][\"Heat Flows Input\"] \n",
    "    minimum_cold_utility=problem_table.iloc[-1][\"Heat Flows Output\"] \n",
    "    hot_composite_curve=pd.DataFrame()\n",
    "    hot_composite_curve[\"Temperature\"]=problem_table[\"Tright\"].values[::-1]\n",
    "    hot_composite_curve[\"Streams Involved\"]=[hot_streams_involved_1[len(hot_streams_involved_1)-i-1] for i in range(len(hot_streams_involved_1))]\n",
    "    k=np.zeros(len(problem_table))\n",
    "    for i in range(len(problem_table)):\n",
    "        streams=np.extract(hot_composite_curve[\"Streams Involved\"][i]!=0, hot_composite_curve[\"Streams Involved\"][i]) \n",
    "        sum_2=0\n",
    "        n=len(streams)\n",
    "        for n in range(len(streams)):\n",
    "            sum_2=sum_2+input_table.loc[streams[n]][\"FCp\"] \n",
    "        k[i]=sum_2\n",
    "    hot_composite_curve[\"Summation of FCp\"]=k\n",
    "    hot_composite_curve[\"Difference\"]=problem_table[\"Temperature Difference\"].values[::-1]\n",
    "    hot_composite_curve[\"Enthalpy not Final\"]=hot_composite_curve[\"Difference\"]*hot_composite_curve[\"Summation of FCp\"]\n",
    "    hot_composite_curve[\"Enthalpy not Final Cumulative\"]=hot_composite_curve[\"Enthalpy not Final\"].cumsum()\n",
    "    final_enthalpy_hot_streams=np.concatenate((0, abs(hot_composite_curve[\"Enthalpy not Final Cumulative\"]).values[:-1]), axis=None)\n",
    "    x=np.array(final_enthalpy_hot_streams,dtype=np.float)\n",
    "    y=np.array(hot_composite_curve[\"Temperature\"],dtype=np.float)\n",
    "    hot_streams; z=hot_streams[\"Ts\"].append(hot_streams[\"Tt\"])\n",
    "    temp_values_of_hot_streams=np.array(z)\n",
    "    hot_composite_curve=pd.DataFrame()\n",
    "    hot_composite_curve[\"Temperature\"]=y\n",
    "    hot_composite_curve[\"Final Enthalpy\"]=x\n",
    "    hot_composite_curve=hot_composite_curve[hot_composite_curve['Temperature'].isin(z)]\n",
    "    cold_composite_curve=pd.DataFrame()\n",
    "    cold_composite_curve[\"Temperature\"]=problem_table[\"Tleft\"].values[::-1]\n",
    "    cold_composite_curve[\"Streams Involved\"]=[cold_streams_involved_1[len(cold_streams_involved_1)-i-1] for i in range(len(cold_streams_involved_1))]\n",
    "    k=np.zeros(len(problem_table))\n",
    "    for i in range(len(problem_table)):\n",
    "        streams=np.extract(cold_composite_curve[\"Streams Involved\"][i]!=0, cold_composite_curve[\"Streams Involved\"][i]) \n",
    "        sum_3=0\n",
    "        n=len(streams)\n",
    "        for n in range(len(streams)):\n",
    "            sum_3=sum_3+input_table.loc[streams[n]][\"FCp\"] \n",
    "        k[i]=sum_3\n",
    "    cold_composite_curve[\"Summation of FCp\"]=k\n",
    "    cold_composite_curve[\"Difference\"]=problem_table[\"Temperature Difference\"].values[::-1]\n",
    "    cold_composite_curve[\"Enthalpy not Final\"]=cold_composite_curve[\"Difference\"]*cold_composite_curve[\"Summation of FCp\"]\n",
    "    cold_composite_curve[\"Enthalpy not Final Cumulative\"]=cold_composite_curve[\"Enthalpy not Final\"].cumsum()\n",
    "    final_enthalpy_cold_streams=np.concatenate((0, abs(cold_composite_curve[\"Enthalpy not Final Cumulative\"]).values[:-1]), axis=None)\n",
    "    a=np.array(final_enthalpy_cold_streams,dtype=np.float)\n",
    "    b=np.array(cold_composite_curve[\"Temperature\"],dtype=np.float)\n",
    "    cold_streams; c=cold_streams[\"Ts\"].append(cold_streams[\"Tt\"])\n",
    "    temp_values_of_cold_streams=np.array(c)\n",
    "    cold_composite_curve=pd.DataFrame()\n",
    "    cold_composite_curve[\"Temperature\"]=b\n",
    "    cold_composite_curve[\"Final Enthalpy\"]=a+minimum_cold_utility\n",
    "    cold_composite_curve=cold_composite_curve[cold_composite_curve['Temperature'].isin(c)]\n",
    "    f = interpolate.interp1d(cold_composite_curve[\"Final Enthalpy\"], cold_composite_curve[\"Temperature\"],bounds_error=False)\n",
    "    g=interpolate.interp1d(hot_composite_curve[\"Final Enthalpy\"], hot_composite_curve[\"Temperature\"],bounds_error=False)\n",
    "    extra_temp_hot=g(cold_composite_curve[\"Final Enthalpy\"]);extra_enthalpy_hot=cold_composite_curve[\"Final Enthalpy\"].to_numpy()\n",
    "    temp={\"Temperature\":extra_temp_hot,\"Final Enthalpy\":extra_enthalpy_hot}\n",
    "    temp2=pd.DataFrame(temp)\n",
    "    hot_composite_duplicate=pd.concat([hot_composite_curve,temp2])\n",
    "    hot_composite_duplicate=hot_composite_duplicate.drop_duplicates()\n",
    "    hot_composite_duplicate=hot_composite_duplicate.sort_values('Final Enthalpy', ascending=True)\n",
    "    hot_composite_duplicate=hot_composite_duplicate.reset_index(drop=True)\n",
    "    extra_temp_cold=f(hot_composite_curve[\"Final Enthalpy\"]);extra_enthalpy_cold=hot_composite_curve[\"Final Enthalpy\"].to_numpy()\n",
    "    temp={\"Temperature\":extra_temp_cold,\"Final Enthalpy\":extra_enthalpy_cold}\n",
    "    temp2=pd.DataFrame(temp)\n",
    "    cold_composite_duplicate=pd.concat([cold_composite_curve,temp2])\n",
    "    cold_composite_duplicate=cold_composite_duplicate.drop_duplicates()\n",
    "    cold_composite_duplicate=cold_composite_duplicate.sort_values('Final Enthalpy', ascending=True)\n",
    "    cold_composite_duplicate=cold_composite_duplicate.reset_index(drop=True)\n",
    "    hot_composite_duplicate = hot_composite_duplicate.rename(columns={'Temperature': 'Temperature of Hot Streams','Final Enthalpy': 'Final Enthalpy of Hot Streams'})\n",
    "    cold_composite_duplicate = cold_composite_duplicate.rename(columns={'Temperature': 'Temperature of Cold Streams','Final Enthalpy':'Final Enthalpy of Cold Streams'})\n",
    "    minimum_area_calculation=pd.concat([hot_composite_duplicate,cold_composite_duplicate],axis=1)\n",
    "    minimum_area_calculation=minimum_area_calculation.drop(['Final Enthalpy of Hot Streams'],axis=1)\n",
    "    minimum_area_calculation=minimum_area_calculation.rename(columns={'Final Enthalpy of Cold Streams':'Final Enthalpy of either streams'})\n",
    "    minimum_area_calculation=minimum_area_calculation.dropna()\n",
    "    minimum_area_calculation=minimum_area_calculation.drop_duplicates(subset='Final Enthalpy of either streams')\n",
    "    summation=[]\n",
    "    for n in range(len(minimum_area_calculation)-1):\n",
    "        deltaTa=minimum_area_calculation[\"Temperature of Hot Streams\"].iloc[n+1]-minimum_area_calculation[\"Temperature of Cold Streams\"].iloc[n+1]\n",
    "        deltaTb=minimum_area_calculation[\"Temperature of Hot Streams\"].iloc[n]-minimum_area_calculation[\"Temperature of Cold Streams\"].iloc[n]\n",
    "        if deltaTa==deltaTb:\n",
    "            LMTD=deltaTa\n",
    "        else:\n",
    "            LMTD=abs(deltaTa-deltaTb)/abs(math.log(abs(deltaTa/deltaTb)))\n",
    "        deltaH=minimum_area_calculation[\"Final Enthalpy of either streams\"].iloc[n+1]-minimum_area_calculation[\"Final Enthalpy of either streams\"].iloc[n]\n",
    "        summation.append(deltaH/LMTD)\n",
    "    final_summation=sum(summation)\n",
    "    minimum_total_area_required_in_m2.append(final_summation*1000/(U))\n",
    "    minimum_hot_utility_required_in_kW.append(minimum_hot_utility)\n",
    "    minimum_cold_utility_required_in_kW.append(minimum_cold_utility)\n",
    "    pinch_temperature_in_degC.append(pinch_temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br> Exporting the necessary data into a Pandas DataFrame <br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "optimize=pd.DataFrame()\n",
    "optimize[\"DeltaTmin\"]=Tmin\n",
    "optimize[\"Pinch Temperature\"]=pinch_temperature_in_degC\n",
    "optimize[\"Ideal Minimum Hot Utility Required\"]=minimum_hot_utility_required_in_kW\n",
    "optimize[\"Ideal Minimum Cold Utility Required\"]=minimum_cold_utility_required_in_kW\n",
    "optimize[\"Ideal Minimum Area Required\"]=minimum_total_area_required_in_m2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code to draw graph of Minimum Area vs Minimum Hot Utility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.ylim(0,optimize[\"Ideal Minimum Hot Utility Required\"].max()+5)\n",
    "plt.xlim(0,optimize[\"Ideal Minimum Area Required\"].max()+5)\n",
    "plt.plot(optimize[\"Ideal Minimum Area Required\"],optimize[\"Ideal Minimum Hot Utility Required\"])\n",
    "plt.xlabel(\"Minimum Hot Utility (kW)\")\n",
    "plt.ylabel(\"Minimum Area (m^2)\")\n",
    "plt.title(\"Minimum Area vs Minimum Hot Utility\",fontsize=20)\n",
    "plt.savefig(\"Minimum Area vs Minimum Hot Utility.png\", dpi=300, bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code to draw graph of Minimum Area vs ΔTmin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.xlim(0,105)\n",
    "plt.ylim(0,optimize[\"Ideal Minimum Area Required\"].max()+5)\n",
    "plt.plot(optimize[\"DeltaTmin\"],optimize[\"Ideal Minimum Area Required\"])\n",
    "plt.xlabel(\"ΔTmin (°C)\")\n",
    "plt.ylabel(\"Minimum Area (m^2)\")\n",
    "plt.title(\"Minimum Area vs ΔTmin\")\n",
    "plt.savefig(\"Minimum Area vs ΔTmin.png\", dpi=300, bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code to graph of Minimum Utility vs ΔTmin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.ylim(0,1.1*(optimize[\"Ideal Minimum Hot Utility Required\"].max()+optimize[\"Ideal Minimum Cold Utility Required\"].max()))\n",
    "plt.xlim(0,110)\n",
    "plt.plot(optimize[\"DeltaTmin\"],optimize[\"Ideal Minimum Hot Utility Required\"],color='red',label='Minimum Hot Utility Required')\n",
    "plt.plot(optimize[\"DeltaTmin\"],optimize[\"Ideal Minimum Cold Utility Required\"],color='blue',label='Minimum Cold Utility Required')\n",
    "plt.plot(optimize[\"DeltaTmin\"],optimize[\"Ideal Minimum Cold Utility Required\"]+optimize[\"Ideal Minimum Hot Utility Required\"],color='black',label='Total Minimum Utility Required')\n",
    "plt.xlabel(\"ΔTmin (°C)\")\n",
    "plt.ylabel(\"Minimum Utility (kW)\")\n",
    "plt.title(\"Minimum Utility vs ΔTmin\")\n",
    "plt.legend()\n",
    "plt.savefig(\"Minimum Utility vs ΔTmin.png\", dpi=300, bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Renaming the columns of Pandas DataFrame to include units in final output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimize=optimize.rename(columns={\"DeltaTmin\":\"ΔTmin (°C)\",\"Pinch Temperature\":\"Pinch Temperature (°C)\",\"Ideal Minimum Hot Utility Required\":\"Ideal Minimum Heating Required (kW)\",\"Ideal Minimum Cold Utility Required\":\"Ideal Minimum Cooling Required (kW)\",\n",
    "                \"Ideal Minimum Area Required\":\"Ideal Minimum Area Required (m^2)\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final Pandas DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ΔTmin (°C)</th>\n",
       "      <th>Pinch Temperature (°C)</th>\n",
       "      <th>Ideal Minimum Heating Required (kW)</th>\n",
       "      <th>Ideal Minimum Cooling Required (kW)</th>\n",
       "      <th>Ideal Minimum Area Required (m^2)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>77.278764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>77.278764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>77.278764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>77.278764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>77.278764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>96.0</td>\n",
       "      <td>176.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>97.0</td>\n",
       "      <td>177.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>98.0</td>\n",
       "      <td>178.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>99.0</td>\n",
       "      <td>179.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>100.0</td>\n",
       "      <td>180.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>240.0</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    ΔTmin (°C)  Pinch Temperature (°C)  Ideal Minimum Heating Required (kW)  \\\n",
       "0          1.0                   170.0                                  0.0   \n",
       "1          2.0                   170.0                                  0.0   \n",
       "2          3.0                   170.0                                  0.0   \n",
       "3          4.0                   170.0                                  0.0   \n",
       "4          5.0                   170.0                                  0.0   \n",
       "..         ...                     ...                                  ...   \n",
       "95        96.0                   176.0                                240.0   \n",
       "96        97.0                   177.0                                240.0   \n",
       "97        98.0                   178.0                                240.0   \n",
       "98        99.0                   179.0                                240.0   \n",
       "99       100.0                   180.0                                240.0   \n",
       "\n",
       "    Ideal Minimum Cooling Required (kW)  Ideal Minimum Area Required (m^2)  \n",
       "0                                   0.0                          77.278764  \n",
       "1                                   0.0                          77.278764  \n",
       "2                                   0.0                          77.278764  \n",
       "3                                   0.0                          77.278764  \n",
       "4                                   0.0                          77.278764  \n",
       "..                                  ...                                ...  \n",
       "95                                240.0                           0.000000  \n",
       "96                                240.0                           0.000000  \n",
       "97                                240.0                           0.000000  \n",
       "98                                240.0                           0.000000  \n",
       "99                                240.0                           0.000000  \n",
       "\n",
       "[100 rows x 5 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exporting the Pandas Dataframe to an Excel Sheet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter('Optimization of ΔTmin.xlsx',engine='xlsxwriter')   \n",
    "workbook=writer.book\n",
    "worksheet=workbook.add_worksheet('Sheet 1')\n",
    "writer.sheets['Sheet 1'] = worksheet\n",
    "optimize.to_excel(writer,sheet_name='Sheet 1',startrow=0 , startcol=0)   \n",
    "writer.save()"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}