diff --git a/notebooks/contrib-dev/Membrane_Model_Transport_Parameters.ipynb b/notebooks/contrib-dev/Membrane_Model_Transport_Parameters.ipynb new file mode 100644 index 00000000..78dbf230 --- /dev/null +++ b/notebooks/contrib-dev/Membrane_Model_Transport_Parameters.ipynb @@ -0,0 +1,990 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Empirical Estimation of Membrane Model Transport Parameters and Performing Model Comparison\n", + "Prepared by Tiago Thomaz Migliati Zanon (tmigliat@nd.edu) and Pratham Singh (psingh4@nd.edu)\n", + "\n", + "**Reference:** The problem is inspired by this research paper: *Haim, O.P., et al., “The adverse effect of concentration polarization on ion-ion selectivity in Nanofiltration” Environmental Science and Technology Letters, 2023 10 (4), 363-371, https://doi.org/10.1021/acs.estlett.3c00124\n", + "\n", + "**Objectives:**\n", + "\n", + "1. Apply knowledge of non-linear regression to find empirical parameters of a\n", + " membrane mass transport model.\n", + "2. Compare two membrane transport models.\n", + "3. Plot and visualize the data.\n", + "\n", + "**Target Audience:** Chemical engineering students.\n", + "\n", + "**Helpful Notebooks to Reference:**\n", + "https://ndcbe.github.io/data-and-computing/notebooks/15/Nonlinear-Regression.html\n", + "\n" + ], + "metadata": { + "id": "sf6fV-Z4IHkp" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Overview: Membrane Transport Model Problem" + ], + "metadata": { + "id": "wBmlIH--KzTE" + } + }, + { + "cell_type": "markdown", + "source": [ + "In the realm of pressure-driven membrane processes, the membrane transport model is crucial for design, development, and optimization. The prevalent Solution Diffusion (SD) model, widely integrated into industrial software, serves as a cornerstone. Another common membrane transport model is Speigler Kedem (SK) Model.\n", + "\n", + "\n", + "\n", + "To validate the applicability of these model, a researcher conducted a specific experiment focusing on Cesium Chloride salt within a nanofiltration filtration system. This experiment involved varied constant flux settings, allowing the observation and measurement of salt rejection across these different flux conditions. The outcomes provide insights into the performance and behavior of the membrane in relation to salt rejection at varying flux. The flux and rejection data is provided in the table below:\n", + "\n", + "\n", + "| Flux (m/s) | Rejection |\n", + "|-|-|\n", + "| 0.000101 | 0.711336|\n", + "| 9.66E-05 | 0.725415|\n", + "|0.000106 | 0.693630|\n", + "|7.97E-05 | 0.711082|\n", + "|7.62E-05\t | 0.728779|\n", + "|8.36E-05\t | 0.699976|\n", + "|5.54E-05\t | 0.702056|\n", + "|5.33E-05\t | 0.705363|\n", + "|5.75E-05\t | 0.669026|\n", + "|3.08E-05\t | 0.637065|\n", + "|2.94E-05\t | 0.646364|\n", + "|3.18E-05\t | 0.598409|\n", + "|4.62E-06\t | 0.408793|\n", + "|4.39E-06\t | 0.299547|\n", + "|4.71E-06\t | 0.290317|\n", + "\n", + "Based on the data provided above we will estimate the salt permeability $ω$ and mass transfer coefficient $k$ using the Solution Diffusion (SD) model and Speigler Kedem (SK) Model.\n" + ], + "metadata": { + "id": "ziHaTbw_LDMD" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Import Libraries" + ], + "metadata": { + "id": "5gDekyz_VVAD" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from scipy.optimize import curve_fit\n", + "from scipy.optimize import least_squares\n", + "from scipy.stats.distributions import t\n", + "import scipy.stats as stats\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import minimize, brute, fmin, fminbound" + ], + "metadata": { + "id": "5d_AcXtTUFcM" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "##1. Solution Diffusion Model" + ], + "metadata": { + "id": "jQDINZ5HYk6c" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Solution Diffusion Model:** The solution-diffusion model is a widely accepted theory that explains the mechanism of membrane transport, particularly in processes like nanofiltration, gas permeation, and dialysis. This model describes how substances move across a semipermeable membrane based on two steps: partioning and diffusion. The governing equation for the model is given below:\n", + "\n", + "$$\n", + "\\frac{Rs}{1 - Rs} = J \\omega e^{\\frac{J}{k}}\n", + "$$\n", + "\n", + "\n", + "The Solution Diffusion (SD) model, expressed by the equation, encapsulates the relationship between salt rejection **Rs** and volumetric flux **J**. In this equation, **Rs** denotes the salt rejection while **J** represents the volumetric flux. The exponent **k** embodies a crucial parameter called mass transfer coefficient." + ], + "metadata": { + "id": "5JtRc155X2WK" + } + }, + { + "cell_type": "markdown", + "source": [ + "###1a. Define SD Model" + ], + "metadata": { + "id": "RHh0b0DmVlnS" + } + }, + { + "cell_type": "code", + "source": [ + "# Add Given Values\n", + "J = np.array([0.000100556, 9.65556E-05, 0.000106222, 7.96667E-05, 7.62222E-05, 8.35556E-05, 5.54074E-05, 5.32593E-05, 5.74815E-05, 3.08148E-05, 2.94074E-05, 3.17778E-05, 4.62222E-06, 4.38889E-06, 4.71111E-06, ])\n", + "Rs = np.array([0.711335686, 0.725415137, 0.693629708, 0.711081808, 0.728778719, 0.699976459, 0.702056047, 0.705362585, 0.669026222, 0.637064923, 0.646363643, 0.598409327, 0.408793422, 0.299546904, 0.290317167, ])\n", + "\n", + "# Convert Rs to Y, where Y is Rs/1-Rs\n", + "Y = Rs/(1-Rs)\n", + "\n", + "# Print Y\n", + "print('Y =',Y)\n", + "\n", + "# Define SD model function\n", + "def SD_Model(theta, J_vals):\n", + " '''\n", + " Function to define SD model\n", + " Arguments:\n", + " J: Volumetric Flux in m/s\n", + " Omega: Salt permeability to be fitted\n", + " k: Mass Transfer coefficient to be fitted by regression\n", + " Returns:\n", + " model: computed value of Rejection by Passage i.e., Y\n", + "\n", + " '''\n", + " omega, k = theta\n", + " Y_vals = J_vals / (omega * np.exp(J_vals / k))\n", + " return Y_vals\n", + "\n", + "def regression_model(theta, J_vals, data):\n", + " Y_pred = SD_Model(theta, J_vals)\n", + " return data - Y_pred\n" + ], + "metadata": { + "id": "F4a5AsQBW-sg", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "543043ec-947c-444d-e32f-131de9c5a9a0" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Y = [2.46423147 2.64186135 2.26402405 2.46118738 2.68702631 2.33307179\n", + " 2.35633595 2.39400208 2.02138739 1.75531373 1.82776355 1.49009767\n", + " 0.69145615 0.42764734 0.40908016]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1b. Perform Non-Linear Regresssion\n", + "\n" + ], + "metadata": { + "id": "hYlsSg-eYtDw" + } + }, + { + "cell_type": "markdown", + "source": [ + "Next, our approach involves non-linear regression through least squares. In Python, the `scipy.optimize` library offers a range of tools tailored for this purpose. Among these tools, the `least_squares` function in this problem. It facilitates the precise fitting of a user-defined function to our data by dynamically adjusting its parameters." + ], + "metadata": { + "id": "jml5leLeMZgC" + } + }, + { + "cell_type": "code", + "source": [ + "theta_guess = [1e-5, 1e-5]\n", + "J_pred = np.linspace(0, 1.2e-4, 100) # Continuous range of J values\n", + "result = least_squares(fun=regression_model, x0=theta_guess, args=(J, Y))\n", + "omega, k = result.x\n", + "\n", + "\n", + "# print the estimated parameters\n", + "print('\\nSalt Permeability:',omega,'m/s')\n", + "print('\\nMass Transfer Coefficient:',k,'m/s')" + ], + "metadata": { + "id": "GDe95X8EZbFH", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6a28df8-0375-4a1a-dd44-b5be9ae49bdd" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Salt Permeability: 1.2295488069945402e-05 m/s\n", + "\n", + "Mass Transfer Coefficient: 8.285491906853397e-05 m/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now calculate the jacobian, variance, and covariance matrix.\n", + "\n", + "$$\n", + "\\Sigma_{\\theta} \\approx \\hat{\\sigma}_e^2 (J^T J)^{-1}\n", + "$$\n", + "\n", + "where $J$ is the Jacobian of the residuals w.r.t. $\\theta$:\n", + "\n", + "$$\n", + "J_{i,j} = \\frac{\\partial(y_i - \\hat{y}_i)}{\\partial \\theta_j}\n", + "$$" + ], + "metadata": { + "id": "qdIPlIxeGK5B" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluating Jacobian Matrix\n", + "Jac = result.jac\n", + "print('Jacobian Matrix\\n', Jac)\n", + "# Finding variance using Jacobian Matrix\n", + "jac_inv = np.linalg.inv(np.dot(Jac.T, Jac))\n", + "vari = J.flatten() - SD_Model(result.x, J)\n", + "variance = np.var(vari)\n", + "print('\\nVariance',variance)\n", + "# Covariance Matrix\n", + "covari= variance * jac_inv\n", + "print('\\nCovariance Matrix\\n',covari)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z4au4c2jGYiC", + "outputId": "5461dbca-3b98-41e0-8ee4-0ec46f9836be" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Jacobian Matrix\n", + " [[197384.70973459 -35589.83511561]\n", + " [198907.69505805 -34437.50234604]\n", + " [194724.65384638 -37088.78140831]\n", + " [201222.36077487 -28744.03298721]\n", + " [200694.59280479 -27429.01189399]\n", + " [201368.16640416 -30169.13408157]\n", + " [187553.57907364 -18632.72308111]\n", + " [185017.40073627 -17668.11507392]\n", + " [189764.08532447 -19558.083397 ]\n", + " [140353.14381914 -7754.48768699]\n", + " [136237.44325176 -7183.30096279]\n", + " [143066.82308486 -8151.4492121 ]\n", + " [ 28880.52656727 -239.33983567]\n", + " [ 27499.96997012 -216.39442838]\n", + " [ 29404.36543629 -248.36727186]]\n", + "\n", + "Variance 0.6387460257033314\n", + "\n", + "Covariance Matrix\n", + " [[1.48583762e-11 1.02883711e-10]\n", + " [1.02883711e-10 7.97143553e-10]]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1c. Plot Residuals" + ], + "metadata": { + "id": "PPgYgIquaVPF" + } + }, + { + "cell_type": "markdown", + "source": [ + "After conducting linear regression analysis, examining residuals becomes essential to evaluate the model's performance and assumptions. Residuals represent the discrepancies between the observed data points and the values predicted by the regression model. Analyzing these residuals helps in assessing the goodness-of-fit, identifying patterns or outliers that the model might have missed, and validating the assumptions underlying the regression analysis.\n", + "\n", + "$$\n", + "\\underbrace{e_i}_{\\mathrm{residual}} = \\underbrace{y_i}_\\mathrm{observation} - \\underbrace{\\hat{y}_i}_{\\mathrm{prediction}}\n", + "$$\n", + "\n", + "Now you should do the following:\n", + "\n", + "1. Calculate the residuals\n", + "\n", + "2. Plot the residuals vs. Volumetric Flux (m/s)" + ], + "metadata": { + "id": "fVBAB4GekkTT" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate the fitted values using the obtained parameters\n", + "fitted_values = SD_Model(result.x, J_pred)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Calculate residuals\n", + "sd_residuals = Y - SD_Model(result.x, J)\n", + "\n", + "# Plot residuals\n", + "plt.figure(figsize=(8, 5))\n", + "plt.scatter(J, sd_residuals, color='red', label='Residuals')\n", + "plt.axhline(y=0, color='black', linestyle='--')\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Residuals (dimensionless)')\n", + "plt.legend()\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SD Model Residuals Plot')\n", + "plt.show()\n" + ], + "metadata": { + "id": "0FDyrZDHadWo", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "outputId": "4f6cee31-16b5-4170-b883-5809fe099b14" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###1d. Plot fitted model and Prediction Interval" + ], + "metadata": { + "id": "gKjZAu_ipjbj" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate standard deviation of residuals\n", + "residual_std = np.std(sd_residuals, ddof=len(result.x))\n", + "\n", + "# Degrees of freedom (modify this according to your specific case)\n", + "dof = len(J) - len(result.x)\n", + "\n", + "# Calculate t-distribution for 95% prediction interval\n", + "t_distribution = t.ppf(0.975, df=dof)\n", + "prediction_interval = t_distribution * residual_std * np.sqrt(1 + variance)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the data points\n", + "plt.scatter(J, Rs, label='Data Points')\n", + "\n", + "# Plot the fitted model\n", + "plt.plot(J_pred, Rs_fitted, label='Solution Diffusion Fitted Model', color='red')\n", + "\n", + "# Plotting the prediction interval\n", + "plt.fill_between(J_pred, Rs_fitted - prediction_interval, Rs_fitted + prediction_interval,\n", + " color='lightgreen', alpha=0.2, label='95% Prediction Interval')\n", + "\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Rejection')\n", + "plt.legend(loc='lower right')\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SD Model with Prediction Interval ')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "ukfdwBH3punS", + "outputId": "a8641468-da24-4df3-b085-1dbb7c09aba5" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##2. Speigler Kedem Film Model" + ], + "metadata": { + "id": "Q38Lw-DZcj0Z" + } + }, + { + "cell_type": "markdown", + "source": [ + "The Speigler-Kedem Film Model, unlike the Solution Diffusion Model, introduces a third parameter known as the reflection coefficient. This model accounts for the convective transport through the membrane along with diffusion.\n", + "\n", + "$$\n", + "\\frac{Rs}{1 - Rs} = \\frac{\\sigma}{1 - \\sigma} \\cdot \\left(1 - \\exp\\left(\\frac{-J(1 - \\sigma)}{\\omega}\\right) \\cdot \\exp\\left(\\frac{-J}{k}\\right)\\right)\n", + "$$\n", + "\n", + "Where:\n", + "- ${\\sigma}$ represents the reflection coefficient.\n", + "- $J $ stands for the volumetric flux\n", + "- $\\omega$ is the salt permeability\n", + "- $k$ denotes the mass transfer coefficient\n", + "- $R_s$ signifies salt rejection\n", + "\n", + "For further information about the model you can check the paper: Murthy, Z.V.P., Gupta, Sharad K., “Estimation of mass transfer coefficient using a combined nonlinear membrane transport and film theory model” Desalination, 1997, 113(3), 237-255, https://doi.org/10.1016/S0011-9164(97)00051-9\n" + ], + "metadata": { + "id": "AYNgyQ9GkZ3u" + } + }, + { + "cell_type": "markdown", + "source": [ + "###2a. Define SK Model" + ], + "metadata": { + "id": "0Sfgo1KUcxPT" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "# Define the SK Model equation\n", + "def sk_model(x, J):\n", + " '''\n", + " Function to define SK model\n", + " Arguments:\n", + " J: Volumetric Flux in m/s\n", + " x: Estimation Parameter (Reflection coefficient, Salt Permeability, Mass Transfer Coefficient)\n", + " Returns:\n", + " The computed value of Y\n", + " '''\n", + "\n", + " a1 = x[0] / (1 - x[0])\n", + " a2 = (1 - x[0]) / x[1]\n", + " return a1 * (1 - np.exp(-J * a2)) * (np.exp(-J / x[2]))\n", + "\n", + "def residual_func(x, J, Y):\n", + " return sk_model(x, J) - Y\n" + ], + "metadata": { + "id": "gFAGYGm2c2qe" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "###2b. Parameter Estimation Using SK Model" + ], + "metadata": { + "id": "n-uxrv11dOEf" + } + }, + { + "cell_type": "markdown", + "source": [ + "For non linear regression here we will again use `least_squares` from `scipy.optimize`" + ], + "metadata": { + "id": "kNK8QE_watwZ" + } + }, + { + "cell_type": "code", + "source": [ + "# Initial guess for parameters x0 and parameter bounds\n", + "x0 = [0.5, 1e-5, 1e-5] # Initial guess for [reflection coefficient, salt permeability, mass transfer coefficient]\n", + "bounds = ([0, 1e-5, 1e-6], [1, 9e-4, 1e-4]) # Bounds for parameters: [0 to 1], [1e-5 to 1e-6], [1e-5 to 1e-6]\n", + "\n", + "# Perform least squares optimization\n", + "result = least_squares(residual_func, x0, bounds=bounds, args=(J, Y))\n", + "\n", + "# Obtained optimized parameters\n", + "optimized_params = result.x\n", + "\n", + "# Print Salt permeability and Mass Transfer Coefficient for SK Model\n", + "print('\\nSalt Permeability:', optimized_params[1], 'm/s')\n", + "print('\\nMass Transfer Coefficient:', optimized_params[2], 'm/s')" + ], + "metadata": { + "id": "FLCUvZX8fdcc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f1de587e-c0c4-46c7-ba06-575a0903a497" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Salt Permeability: 1.1625945932822965e-05 m/s\n", + "\n", + "Mass Transfer Coefficient: 9.999999999999999e-05 m/s\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now calculate the jacobian, variance, and covariance matrix for SK model." + ], + "metadata": { + "id": "kcMEzdACKl23" + } + }, + { + "cell_type": "code", + "source": [ + "# Evaluating Jacobian Matrix\n", + "Jac = result.jac\n", + "print('Jacobian Matrix\\n', Jac)\n", + "# Finding variance using Jacobian Matrix\n", + "jac_inv = np.linalg.inv(np.dot(Jac.T, Jac))\n", + "vari = J.flatten() - sk_model(result.x, J)\n", + "variance = np.var(vari)\n", + "print('\\nVariance',variance)\n", + "# Covariance Matrix\n", + "covari= variance * jac_inv\n", + "print('\\nCovariance Matrix\\n',covari)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iINDYd5xPG9I", + "outputId": "7cbbd629-010d-4650-8165-f51acb40eec4" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Jacobian Matrix\n", + " [[ 1.23018700e+01 -1.66260409e+05 2.44379297e+04]\n", + " [ 1.20337228e+01 -1.69092330e+05 2.36431129e+04]\n", + " [ 1.26362022e+01 -1.61895625e+05 2.54737235e+04]\n", + " [ 1.06004280e+01 -1.77837380e+05 1.97272060e+04]\n", + " [ 1.02479548e+01 -1.78782104e+05 1.88243709e+04]\n", + " [ 1.09739760e+01 -1.76381100e+05 2.07061367e+04]\n", + " [ 7.71067446e+00 -1.75271284e+05 1.27913027e+04]\n", + " [ 7.41315326e+00 -1.73757778e+05 1.21299468e+04]\n", + " [ 7.99233013e+00 -1.76492844e+05 1.34257506e+04]\n", + " [ 4.06265061e+00 -1.38796710e+05 5.33001233e+03]\n", + " [ 3.84673652e+00 -1.35163587e+05 4.93790261e+03]\n", + " [ 4.21061236e+00 -1.41167194e+05 5.60248953e+03]\n", + " [ 4.46478520e-01 -3.03341873e+04 1.64900304e+02]\n", + " [ 4.21760656e-01 -2.88996516e+04 1.49095269e+02]\n", + " [ 4.55951389e-01 -3.08780776e+04 1.71118330e+02]]\n", + "\n", + "Variance 0.6376533479503876\n", + "\n", + "Covariance Matrix\n", + " [[ 2.60203040e+01 3.58103201e-04 -1.07015416e-02]\n", + " [ 3.58103201e-04 4.94179115e-09 -1.47159994e-07]\n", + " [-1.07015416e-02 -1.47159994e-07 4.40253694e-06]]\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###2c. Residual Plot for SK Model" + ], + "metadata": { + "id": "mnrwztuY8pDA" + } + }, + { + "cell_type": "markdown", + "source": [ + "We will now plot the residual vs Volumetric flux plot for SK Model results." + ], + "metadata": { + "id": "ICzcw5n_ctJa" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate the fitted values using the obtained parameters\n", + "fitted_values = sk_model(result.x, J_pred)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Calculate residuals\n", + "sk_residuals = Y - sk_model(result.x, J)\n", + "\n", + "\n", + "# Plot the residuals vs Volumetric flux\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(J, sk_residuals, color='green', label='Residuals')\n", + "plt.xlabel('Volumetric flux (m/s)')\n", + "plt.ylabel('Residuals (Dimensionless)')\n", + "plt.title('SK Model Residuals Plot')\n", + "plt.axhline(y=0, color='red', linestyle='--')\n", + "plt.ylim(-0.4, 0.5)\n", + "plt.legend()\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "o1RYa8338zAh", + "outputId": "aae38a0d-5d42-4466-9847-f8298e37eb44" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "###2d. SK Model Fitting Plot and Prediction Interval" + ], + "metadata": { + "id": "VEt2motnc7NO" + } + }, + { + "cell_type": "code", + "source": [ + "# Calculate standard deviation of residuals\n", + "residual_std = np.std(sk_residuals, ddof=len(result.x))\n", + "\n", + "# Degrees of freedom (modify this according to your specific case)\n", + "dof = len(J) - len(result.x)\n", + "\n", + "# Calculate t-distribution for 95% prediction interval\n", + "t_distribution = t.ppf(0.975, df=dof)\n", + "prediction_interval = t_distribution * residual_std * np.sqrt(1 + variance)\n", + "\n", + "# Calculate Rs values from Y\n", + "Rs_fitted = fitted_values / (1 + fitted_values)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(8, 6))\n", + "\n", + "# Plot the data points\n", + "plt.scatter(J, Rs, label='Data Points')\n", + "\n", + "# Plot the fitted model\n", + "plt.plot(J_pred, Rs_fitted, label='Speigler Kedem Fitted Model', color='orange')\n", + "\n", + "# Plotting the prediction interval\n", + "plt.fill_between(J_pred, Rs_fitted - prediction_interval, Rs_fitted + prediction_interval,\n", + " color='lightgreen', alpha=0.2, label='95% Prediction Interval')\n", + "\n", + "plt.xlabel('Volumetric Flux (m/s)')\n", + "plt.ylabel('Rejection')\n", + "plt.legend(loc='lower right')\n", + "plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))\n", + "plt.title('SK Model with Prediction Interval ')\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "Lt5RYvAjdWw7", + "outputId": "0845ac24-ecdf-4fa0-f486-ad5c6aaceffe" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##3. Comparision: SD Model vs SK Model" + ], + "metadata": { + "id": "DhmSstOEfz_N" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now we will do a statistical comparison of the SD model (two parameter model) and SK Model (three parameter model) using Akaike's Information Criterion." + ], + "metadata": { + "id": "vXHKDNANkj3R" + } + }, + { + "cell_type": "markdown", + "source": [ + "###3a. Akaike's Information Criterion (AIC)\n", + "\n", + "Akaike's Information Criterion (AIC) is a measure used for model selection that balances model fit and complexity. It quantifies the trade-off between the goodness of fit and the number of parameters in a statistical model.\n", + "\n", + "The equation for AIC is:\n", + "\n", + "$$\n", + "\\text{AIC} = 2k - 2\\ln(\\hat{L})\n", + "$$\n", + "\n", + "Where:\n", + "**k** is the number of estimated parameters in the model.\n", + "**L** is the maximum value of the likelihood function for the model.\n", + "\n", + "This way, lower AIC indicates a better trade-off between model fit and complexity. So, among competing models, the one with the lowest AIC is considered to be the best in balancing goodness of fit and simplicity.\n", + "\n", + "For small sample size AIC can be modified for better estimation by the following equation:\n", + "\n", + "$$\n", + "\\text{AICc} = AIC + {\\frac{((2k)^2 +2k)}{n - k -1}}\n", + "$$\n", + "\n", + "After the AIC is evaluated, we can perform f test if the error is higher for the preferred model justify the statistical comparison.\n" + ], + "metadata": { + "id": "SPvtCmxogAjw" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "\n", + "# Define a function for AIC\n", + "\n", + "def aic_f(k1,k2,rss_sd, rss_sk):\n", + " if k2+1 >= n:\n", + " print('number of observations should be 2 more than fitting parameter to perform AIC or f test')\n", + " else:\n", + " aic_sd = 2*k1 + n*np.log(rss_sd/n)\n", + " # AIC corrected for small no. of observation points\n", + " num = 2*(k1)**2 + 2*k1\n", + " denom = n - k1 - 1\n", + " #AIC for SD Model\n", + " AICc_sd = aic_sd + (num/denom)\n", + "\n", + " #AIC for SK Model\n", + " aic_sk = 2*k2 + n*np.log(rss_sk/n)\n", + " num = 2*(k2)**2 + 2*k2\n", + " denom = n - k2 - 1\n", + " AICc_sk = aic_sk + (num/denom)\n", + " print('AIC for SD model is ', AICc_sd)\n", + " print('AIC for SK model is ', AICc_sk)\n", + " if AICc_sd < AICc_sk:\n", + " print('AIC - SD model is better fit to the data than SK model' )\n", + " else:\n", + " print('AIC - SK model is better fit to the data than SD model' )\n", + "\n", + "\n", + " # F-Test\n", + " # calculated f is greater than f critical and p value less than alpha(0.05) then null hypothesis is rejected\n", + " if rss_sd > rss_sk:\n", + " n1 = (rss_sd - rss_sk)/ (fp2 - fp1)\n", + " d1 = (rss_sk) / (n - fp2)\n", + " ft = n1 / d1\n", + " p_value = 1-stats.f.cdf(ft, (fp2-fp1), (n-fp2))\n", + " f_critical = stats.f.ppf(q=1-alpha, dfn= fp2-fp1 , dfd= n-fp2)\n", + " print('\\nf=',ft, '\\nf*=',f_critical, '\\np_value=', p_value)\n", + "\n", + "\n", + " if ft < f_critical and p_value >= alpha :\n", + " print('F Test - SD model fits better to the data than SK model ')\n", + " else:\n", + " print ('F Test -SK model fits better to the data than SD model')\n", + " else:\n", + " print('f test - SD model has low error and fits better than SK model')\n", + "\n", + " return\n" + ], + "metadata": { + "id": "9hAjzLGYgY0m" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now call the AIC function to compare the model" + ], + "metadata": { + "id": "3gcR6yffcqGA" + } + }, + { + "cell_type": "code", + "source": [ + "fp1 = 2 # number of fitted parameter in SD MODEL\n", + "fp2 = 3 # number of fitted parameter in SK MODEL\n", + "\n", + "n = len(Y) # number of data points\n", + "p = len(optimized_params) # number of parameters\n", + "alpha = 0.05 # 95% confidence interval = 100*(1-alpha)\n", + "\n", + "# k1 for SD and k2 SK is number of fitted parameter + 1, used for AIC\n", + "k1= fp1+1\n", + "k2 = fp2 +1\n", + "\n", + "rss_sk = sum(sk_residuals)**2 # residual sum of squares for SK model\n", + "rss_sd = sum((sd_residuals)**2) # residual sum of squares for SD model\n", + "\n", + "\n", + "# Call the AIC function\n", + "aic_f(k1,k2,rss_sd, rss_sk)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yE6b-p78cxOt", + "outputId": "e9afc990-4f61-41b6-f3f3-da83b9386a48" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "AIC for SD model is -44.10766253375572\n", + "AIC for SK model is -58.221060291972066\n", + "AIC - SK model is better fit to the data than SD model\n", + "\n", + "f= 27.660085868866968 \n", + "f*= 4.747225346722511 \n", + "p_value= 0.00020131060639594356\n", + "F Test -SK model fits better to the data than SD model\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "##4. Discussion" + ], + "metadata": { + "id": "mCoTrW86jKlB" + } + }, + { + "cell_type": "markdown", + "source": [ + "Question 1: According to your estimation, is there a significant difference when using three parameter model (SK Model) vs two parameter model (SD Model)? Which one do you think is better for this data?\n", + "\n", + "Answer: Although the models looks really similar in terms of output, the SK model here gives a better estimation than SD model. This can be verified by the AIC and f test results and we can conclude that convective transport is important to consider for this set of data.\n", + "\n", + "Question 2: Do the two membrane transport models give the same or different estimates for Salt Permeability and Mass Transfer Coefficient ?\n", + "\n", + "Answer: The two models gives different values for Salt Permeability and Mass Transfer Coefficient. However, the estimated values are close to each other.\n", + "\n", + "Question 3: Why do you think the residual are dimensionless for the data? Justify in one or two sentences\n", + "\n", + "Answer: Residual in the above data is for the rejection data. The rejection in itself is dimensionless.\n", + "\n", + "\n" + ], + "metadata": { + "id": "oZ83z-VmjNRn" + } + }, + { + "cell_type": "markdown", + "source": [ + "##References\n", + "1. Wijmans, J.G., Baker, R.W., “The solution-diffusion model: a review” Journal of Membrane Science, 1995 107, 1-21, https://doi.org/10.1016/0376-7388(95)00102-I\n", + "2. Haim, O.P., Shefer, I., Singh, P., Nir, O., Epsztein, R., “The adverse effect of concentration polarization on ion-ion selectivity in Nanofiltration” Environmental Science and Technology Letters, 2023 10 (4), 363-371, https://doi.org/10.1021/acs.estlett.3c00124\n", + "3. Murthy, Z.V.P., Gupta, Sharad K., “Estimation of mass transfer coefficient using a combined nonlinear membrane transport and film theory model” Desalination, 1997 109 (1), 39-49, https://doi.org/10.1016/S0011-9164(97)00051-9\n" + ], + "metadata": { + "id": "yLi3JSCfjz3i" + } + } + ] +} \ No newline at end of file