diff --git a/.github/workflows/binder.yaml b/.github/workflows/binder.yaml new file mode 100644 index 00000000..0f5690e7 Binary files /dev/null and b/.github/workflows/binder.yaml differ diff --git a/docs/source/conf.py b/docs/source/conf.py index 2e7bbf8b..524df415 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -31,7 +31,7 @@ # built documents. # # The short X.Y version. -version = '1.3.0' +version = '1.3.1' # The full version, including alpha/beta/rc tags. release = version @@ -127,10 +127,10 @@ # -- External mapping ------------------------------------------------------- intersphinx_mapping = { - 'biosteam': ('https://biosteam.readthedocs.io/en/latest', None), - 'thermosteam': ('https://biosteam.readthedocs.io/en/latest', None), - 'BioSTEAM': ('https://biosteam.readthedocs.io/en/latest', None), - 'Thermosteam': ('https://biosteam.readthedocs.io/en/latest', None), - 'scipy': ('https://docs.scipy.org/doc/scipy/', None), - 'SALib': ('https://salib.readthedocs.io/en/latest', None), + 'biosteam': ('https://biosteam.readthedocs.io', None), + 'thermosteam': ('https://biosteam.readthedocs.io', None), + 'BioSTEAM': ('https://biosteam.readthedocs.io', None), + 'Thermosteam': ('https://biosteam.readthedocs.io', None), + 'scipy': ('https://docs.scipy.org/doc/scipy', None), + 'SALib': ('https://salib.readthedocs.io', None), } diff --git a/docs/source/tutorials/10_Process.ipynb b/docs/source/tutorials/10_Process.ipynb index 73b8659b..2a4817a6 100644 --- a/docs/source/tutorials/10_Process.ipynb +++ b/docs/source/tutorials/10_Process.ipynb @@ -20,7 +20,7 @@ " \n", "- **Video demo:**\n", "\n", - " - [Joy Zhang](https://qsdsan.readthedocs.io/en/latest/authors/Joy_Zhang.html)\n", + " - [Joy Zhang](https://qsdsan.readthedocs.io/en/latest/CONTRIBUTING.html)\n", " \n", "To run tutorials in your browser, go to this [Binder page](https://mybinder.org/v2/gh/QSD-Group/QSDsan/main?filepath=%2Fdocs%2Fsource%2Ftutorials).\n", " \n", diff --git a/docs/source/tutorials/11_Dynamic_Simulation.ipynb b/docs/source/tutorials/11_Dynamic_Simulation.ipynb index ba9c9bbe..4f990179 100644 --- a/docs/source/tutorials/11_Dynamic_Simulation.ipynb +++ b/docs/source/tutorials/11_Dynamic_Simulation.ipynb @@ -3,7 +3,11 @@ { "cell_type": "markdown", "id": "28c4658c", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "# Dynamic Simulation \n", "\n", @@ -19,17 +23,21 @@ " \n", "- **Video demo:**\n", "\n", - " - To be posted\n", + " - [Yalin Li](https://qsdsan.readthedocs.io/en/latest/CONTRIBUTING.html)\n", " \n", "To run tutorials in your browser, go to this [Binder page](https://mybinder.org/v2/gh/QSD-Group/QSDsan/main?filepath=%2Fdocs%2Fsource%2Ftutorials).\n", " \n", - "You can also watch a video demo on YouTube (link to be posted) (subscriptions & likes appreciated!)." + "You can also watch a video demo on [YouTube](https://youtu.be/1Rr1QxUiE5k) (subscriptions & likes appreciated!)." ] }, { "cell_type": "markdown", "id": "2bc790e7", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "---\n", "From previous tutorials, we've covered how to use QSDsan's [SanUnit](https://qsdsan.readthedocs.io/en/latest/tutorials/5_SanUnit_advanced.html) and [WasteStream](https://qsdsan.readthedocs.io/en/latest/tutorials/3_WasteStream.html) classes to model the mass/energy flows throughout a system. You may have noticed, the simulation results generated by `SanUnit._run` are **static**, i.e., they don't carry time-related information. \n", @@ -41,13 +49,17 @@ "cell_type": "code", "execution_count": 1, "id": "3dc1138e", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "This tutorial was made with qsdsan v1.2.5 and exposan v1.2.5\n" + "This tutorial was made with qsdsan v1.3.1 and exposan v1.3.1\n" ] } ], @@ -59,15 +71,29 @@ { "cell_type": "markdown", "id": "b7f9ccfc", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## 1. Understanding dynamic simulation with QSDsan \n", "\n", "### 1.1. An example system\n", "Let's use [Benchmark Simulation Model no.1 (BSM1)](http://iwa-mia.org/benchmarking/#BSM1) as an example. BSM1 describes an activated sludge treatment process that can be commonly found in conventional wastewater treatment facilities. The full system has been implemented in [EXPOsan](https://github.com/QSD-Group/EXPOsan/tree/main/exposan/bsm1).\n", "\n", - "The activated sludge process is often characterized as a series of biokinetic reactions in parallel (recap on `Process` [here](https://qsdsan.readthedocs.io/en/latest/tutorials/10_Process.html)). The mathematical models of this kind cannot output mass flows or concentrations directly as a function of input. But rather, they describe the rates of change in state variables at any time as a function of the state variables (often concentrations). As a result, simulation of such systems involves solving a series of ordinary differential equations (ODEs). We have developed features in QSDsan for this specific purpose.\n", - "\n", + "The activated sludge process is often characterized as a series of biokinetic reactions in parallel (recap on `Process` [here](https://qsdsan.readthedocs.io/en/latest/tutorials/10_Process.html)). The mathematical models of this kind cannot output mass flows or concentrations directly as a function of input. But rather, they describe the rates of change in state variables at any time as a function of the state variables (often concentrations). As a result, simulation of such systems involves solving a series of ordinary differential equations (ODEs). We have developed features in QSDsan for this specific purpose." + ] + }, + { + "cell_type": "markdown", + "id": "a8a07c91", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ "#### 1.1.1. Running dynamic simulation" ] }, @@ -75,7 +101,11 @@ "cell_type": "code", "execution_count": 2, "id": "a1c82016", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "name": "stdout", @@ -83,7 +113,7 @@ "text": [ "System: bsm1_sys\n", "ins...\n", - "[0] wastewater\n", + "[0] wastewater \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow (kmol/hr): S_I 23.1\n", " S_S 53.4\n", @@ -94,10 +124,10 @@ " S_ND 0.381\n", " ... 4.26e+04\n", "outs...\n", - "[0] effluent\n", + "[0] effluent \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow: 0\n", - "[1] WAS\n", + "[1] WAS \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow: 0\n" ] @@ -115,178 +145,236 @@ "cell_type": "code", "execution_count": 3, "id": "61ef9ac7", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "image/svg+xml": [ - "\n", + "\n", "\n", - "\n", + "\n", "\n", - "A1CSTR:c->A2CSTR:c\n", - "\n", - "\n", + "A1\n", + "CSTR:c->A2\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " ws1\n", + " ws1\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "A2CSTR:c->O1CSTR:c\n", - "\n", - "\n", + "A2\n", + "CSTR:c->O1\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " ws3\n", + " ws3\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O1CSTR:c->O2CSTR:c\n", - "\n", - "\n", + "O1\n", + "CSTR:c->O2\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " ws5\n", + " ws5\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O2CSTR:c->O3CSTR:c\n", - "\n", - "\n", + "O2\n", + "CSTR:c->O3\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " ws7\n", + " ws7\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O3CSTR:c->A1CSTR:c\n", - "\n", - "\n", + "O3\n", + "CSTR:c->A1\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " RWW\n", + " RWW\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O3CSTR:c->C1Flat bottom circular clarifier:c\n", - "\n", - "\n", + "O3\n", + "CSTR:c->C1\n", + "Flat bottom circular clarifier:c\n", + "\n", + "\n", "\n", - " treated\n", + " treated\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "C1Flat bottom circular clarifier:c->A1CSTR:c\n", - "\n", - "\n", + "C1\n", + "Flat bottom circular clarifier:c->A1\n", + "CSTR:c\n", + "\n", + "\n", "\n", - " RAS\n", + " RAS\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "C1Flat bottom circular clarifier:c-> effluent:w\n", - "\n", + "C1\n", + "Flat bottom circular clarifier:c->77295603618:w\n", + "\n", "\n", - " effluent\n", + " effluent\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "C1Flat bottom circular clarifier:c-> WAS:w\n", - "\n", + "C1\n", + "Flat bottom circular clarifier:c->77295603938:w\n", + "\n", "\n", - " WAS\n", + " WAS\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - " wastewater:e->A1CSTR:c\n", - "\n", - "\n", + "77280229462:e->A1\n", + "CSTR:c\n", + "\n", + "\n", " wastewater\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "A1CSTR\n", + "A1\n", + "CSTR\n", "\n", - "\n", - "A1CSTR\n", + "\n", + "A1\n", + "CSTR\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "A2CSTR\n", + "A2\n", + "CSTR\n", "\n", - "\n", - "A2CSTR\n", + "\n", + "A2\n", + "CSTR\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O1CSTR\n", + "O1\n", + "CSTR\n", "\n", - "\n", - "O1CSTR\n", + "\n", + "O1\n", + "CSTR\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O2CSTR\n", + "O2\n", + "CSTR\n", "\n", - "\n", - "O2CSTR\n", + "\n", + "O2\n", + "CSTR\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "O3CSTR\n", + "O3\n", + "CSTR\n", "\n", - "\n", - "O3CSTR\n", + "\n", + "O3\n", + "CSTR\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "C1Flat bottom circular clarifier\n", + "C1\n", + "Flat bottom circular clarifier\n", "\n", - "\n", - "C1Flat bottom circular clarifier\n", + "\n", + "C1\n", + "Flat bottom circular clarifier\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - " wastewater\n", + "77280229462\n", "\n", "\n", - "\n", + "\n", "\n", - " effluent\n", - "\n", + "77295603618\n", + "\n", "\n", - "\n", + "\n", "\n", - " WAS\n", - "\n", + "77295603938\n", + "\n", "\n", "\n", "" @@ -302,15 +390,19 @@ "source": [ "# The BSM1 system is composed of 5 CSTRs in series, \n", "# followed by a flat-bottom circular clarifier.\n", - "sys.diagram()\n", - "# sys.units" + "# sys.units\n", + "sys.diagram()" ] }, { "cell_type": "code", "execution_count": 4, "id": "03c7b593", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# If we try to simulate it like we'd do for a \"static\" system\n", @@ -320,16 +412,24 @@ { "cell_type": "markdown", "id": "07f91f64", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "We run into this error because QSDsan (essentially biosteam in the background) considers this system dynamic, and additional arguments are required for `simulate` to work." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "b349b9a3", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -337,7 +437,7 @@ "True" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -349,52 +449,64 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "43772dae", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{: True,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : True}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "slideshow": { + "slide_type": "slide" } - ], + }, + "outputs": [], "source": [ "# This is because the system contains at least one dynamic SanUnit\n", - "{u: u.isdynamic for u in sys.units}\n", + "# {u: u.isdynamic for u in sys.units}\n", "\n", "# If we disable dynamic simulation, then `simulate` would work as usual\n", - "# sys.isdynamic = False\n", - "# sys.simulate()" + "sys.isdynamic = False\n", + "sys.simulate()" ] }, { "cell_type": "markdown", "id": "cc28e85f", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "To perform a dynamic simulation of the system, we need to provide at least one additional keyword argument, i.e., `t_span`, as suggested in the error message. `t_span` is a 2-tuple indicating the simulation period.\n", "\n", - ">**Note**: Whether `t_span = (0,10)` means 0-10 days or 0-10 hours/minutes/months depends entirely on units of the parameters in the system's ODEs. For BSM1, it'd mean 0-10 days because all parameters in the ODEs express time in the unit of \"day\".\n", - "\n", + ">**Note**: Whether `t_span = (0,10)` means 0-10 days or 0-10 hours/minutes/months depends entirely on units of the parameters in the system's ODEs. For BSM1, it'd mean 0-10 days because all parameters in the ODEs express time in the unit of \"day\"." + ] + }, + { + "cell_type": "markdown", + "id": "0c111c81", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "Other often-used keyword arguments include:\n", "\n", "- `t_eval`: a 1d array to specify the output time points\n", "- `method`: a string specifying the ODE solver\n", "- `state_reset_hook`: specifies how to reset the simulation\n", "\n", - "`t_span`, `t_eval`, and `method` are essentially passed to [scipy.integrate.solve_ivp](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html) function as keyword arguments. See [documentation](https://biosteam.readthedocs.io/en/latest/API/System.html#biosteam.System.dynamic_run) for a complete list of keyword arguments. You may notice that `scipy.integrate.solve_ivp` also requires input of `fun` (i.e., the ODEs) and `y0` (i.e., the initial condition). We'll learn later how `System.simulate` automates the compilation of these inputs.\n", - "\n", + "`t_span`, `t_eval`, and `method` are essentially passed to [scipy.integrate.solve_ivp](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html) function as keyword arguments. See [documentation](https://biosteam.readthedocs.io/en/latest/API/System.html#biosteam.System.dynamic_run) for a complete list of keyword arguments. You may notice that `scipy.integrate.solve_ivp` also requires input of `fun` (i.e., the ODEs) and `y0` (i.e., the initial condition). We'll learn later how `System.simulate` automates the compilation of these inputs." + ] + }, + { + "cell_type": "markdown", + "id": "9c8b4556", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "---\n", "### Tip\n", "For systems that are expected to converge to some sort of \"steady state\", it is usually faster to simulate with implicit ODE solvers (e.g., `method = BDF` or `method = LSODA`) than with explicit ones. In case of one solver fails to complete integration through the entire specified simulation period, always try with alternative ones.\n", @@ -404,9 +516,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "45ef4032", - "metadata": {}, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "name": "stdout", @@ -415,10 +532,10 @@ "System: bsm1_sys\n", "Highest convergence error among components in recycle\n", "streams {C1-1, O3-0} after 5 loops:\n", - "- flow rate 7.28e-12 kmol/hr (7.6e-14%)\n", + "- flow rate 1.46e-11 kmol/hr (4.2e-14%)\n", "- temperature 0.00e+00 K (0%)\n", "ins...\n", - "[0] wastewater\n", + "[0] wastewater \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow (kmol/hr): S_I 23.1\n", " S_S 53.4\n", @@ -429,7 +546,7 @@ " S_ND 0.381\n", " ... 4.26e+04\n", "outs...\n", - "[0] effluent\n", + "[0] effluent \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow (kmol/hr): S_I 22.6\n", " S_S 0.67\n", @@ -439,7 +556,7 @@ " X_BA 0.43\n", " X_P 1.3\n", " ... 4.17e+04\n", - "[1] WAS\n", + "[1] WAS \n", " phase: 'l', T: 293.15 K, P: 101325 Pa\n", " flow (kmol/hr): S_I 0.481\n", " S_S 0.0143\n", @@ -448,12 +565,13 @@ " X_BH 80.3\n", " X_BA 4.69\n", " X_P 14.1\n", - " ... 885\n" + " ... 884\n" ] } ], "source": [ "# Let's try simulating the BSM1 system from day 0 to day 50\n", + "sys.isdynamic = True\n", "sys.simulate(t_span=(0, 50), method='BDF', state_reset_hook='reset_cache')\n", "sys.show()" ] @@ -461,19 +579,25 @@ { "cell_type": "markdown", "id": "972442da", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ - "[Back to top](#top)\n", - "\n", "#### 1.1.2. Retrieve dynamic simulation data\n", "The `show` method only displays the system's state at the end of the simulation period. How do we retrieve information on system dynamics? QSDsan uses [Scope](https://qsdsan.readthedocs.io/en/latest/api/utils/scope.html) objects to keep track of values of state variables during simulation." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "3d7a8b0d", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -481,7 +605,7 @@ "(, )" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -494,9 +618,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "5fedeb57", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -504,7 +632,7 @@ "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -521,13 +649,17 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "a7c7fa4d", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -543,91 +675,97 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "51cc75b4", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ - "array([[3.000e+01, 5.000e+00, 1.000e+03, ..., 4.152e-11, 9.379e-05,\n", - " 9.223e+04],\n", - " [3.000e+01, 5.000e+00, 1.000e+03, ..., 4.194e-09, 9.473e-03,\n", - " 9.223e+04],\n", - " [3.000e+01, 5.000e+00, 1.000e+03, ..., 8.346e-09, 1.885e-02,\n", - " 9.223e+04],\n", - " ...,\n", - " [3.000e+01, 2.811e+00, 1.146e+03, ..., 2.500e+01, 9.986e+05,\n", - " 9.223e+04],\n", - " [3.000e+01, 2.810e+00, 1.147e+03, ..., 2.501e+01, 9.986e+05,\n", - " 9.223e+04],\n", - " [3.000e+01, 2.810e+00, 1.148e+03, ..., 2.501e+01, 9.986e+05,\n", - " 9.223e+04]])" + "array([], shape=(0, 1), dtype=float64)" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Raw time-series data are stored in\n", - "A1.scope.record" + "# A1.scope.record\n", + "A2 = sys.flowsheet.unit.A2\n", + "A2.scope\n", + "A2.scope.record" ] }, { "cell_type": "markdown", "id": "8b8727df", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "Each row in the `record` attribute is values of `A1`'s state variables at a certain time point." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "cab34aab", "metadata": { - "scrolled": true + "scrolled": true, + "slideshow": { + "slide_type": "slide" + } }, "outputs": [ { "data": { "text/plain": [ - "array([0.000e+00, 5.092e-10, 1.018e-09, 6.110e-09, 1.120e-08, 6.212e-08,\n", - " 1.130e-07, 3.163e-07, 5.195e-07, 7.227e-07, 1.402e-06, 2.081e-06,\n", - " 2.761e-06, 8.668e-06, 1.458e-05, 2.048e-05, 3.167e-05, 4.285e-05,\n", - " 5.404e-05, 6.522e-05, 1.049e-04, 1.445e-04, 1.842e-04, 2.238e-04,\n", - " 3.089e-04, 3.940e-04, 4.791e-04, 5.642e-04, 6.493e-04, 8.356e-04,\n", - " 1.022e-03, 1.208e-03, 1.394e-03, 1.581e-03, 1.767e-03, 2.184e-03,\n", - " 2.602e-03, 2.895e-03, 3.188e-03, 3.398e-03, 3.567e-03, 3.736e-03,\n", - " 3.905e-03, 4.038e-03, 4.171e-03, 4.304e-03, 4.437e-03, 4.571e-03,\n", - " 4.704e-03, 4.848e-03, 4.993e-03, 5.138e-03, 5.282e-03, 5.427e-03,\n", - " 5.571e-03, 5.832e-03, 6.092e-03, 6.352e-03, 6.612e-03, 6.872e-03,\n", - " 7.331e-03, 7.790e-03, 8.248e-03, 8.707e-03, 9.408e-03, 1.011e-02,\n", - " 1.081e-02, 1.151e-02, 1.274e-02, 1.396e-02, 1.519e-02, 1.642e-02,\n", - " 1.849e-02, 2.056e-02, 2.196e-02, 2.336e-02, 2.476e-02, 2.616e-02,\n", - " 2.858e-02, 3.100e-02, 3.221e-02, 3.342e-02, 3.463e-02, 3.583e-02,\n", - " 3.704e-02, 3.955e-02, 4.122e-02, 4.290e-02, 4.457e-02, 4.625e-02,\n", - " 5.036e-02, 5.447e-02, 5.858e-02, 6.270e-02, 6.959e-02, 7.649e-02,\n", - " 7.735e-02, 7.821e-02, 7.907e-02, 7.994e-02, 8.083e-02, 8.173e-02,\n", - " 8.262e-02, 8.299e-02, 8.335e-02, 8.367e-02, 8.399e-02, 8.436e-02,\n", - " 8.473e-02, 8.827e-02, 8.872e-02, 8.916e-02, 9.138e-02, 9.359e-02,\n", - " 1.004e-01, 1.072e-01, 1.228e-01, 1.248e-01, 1.267e-01, 1.287e-01,\n", - " 1.291e-01, 1.296e-01, 1.300e-01, 1.344e-01, 1.388e-01, 1.432e-01,\n", - " 1.597e-01, 1.762e-01, 1.927e-01, 1.936e-01, 1.945e-01, 1.954e-01,\n", - " 2.041e-01, 2.128e-01, 2.413e-01, 2.698e-01, 2.983e-01, 2.990e-01,\n", - " 2.997e-01, 3.005e-01, 3.012e-01, 3.083e-01, 3.154e-01, 3.225e-01,\n", - " 3.622e-01, 4.019e-01, 4.416e-01, 5.179e-01, 5.941e-01, 6.703e-01,\n", - " 7.466e-01, 8.335e-01, 9.205e-01, 1.007e+00, 1.094e+00, 1.280e+00,\n", - " 1.466e+00, 1.652e+00, 1.838e+00, 2.148e+00, 2.457e+00, 2.767e+00,\n", - " 3.076e+00, 3.591e+00, 4.106e+00, 4.621e+00, 5.136e+00, 5.874e+00,\n", - " 6.613e+00, 7.351e+00, 8.090e+00, 9.540e+00, 1.099e+01, 1.244e+01,\n", - " 1.389e+01, 1.586e+01, 1.782e+01, 1.979e+01, 2.176e+01, 2.373e+01,\n", - " 2.790e+01, 3.207e+01, 3.624e+01, 4.041e+01, 4.689e+01, 5.000e+01])" + "array([0.000e+00, 5.096e-10, 1.019e-09, 6.115e-09, 1.121e-08, 6.217e-08,\n", + " 1.131e-07, 3.165e-07, 5.198e-07, 7.231e-07, 1.403e-06, 2.082e-06,\n", + " 2.762e-06, 8.671e-06, 1.458e-05, 2.049e-05, 3.168e-05, 4.286e-05,\n", + " 5.405e-05, 6.524e-05, 1.049e-04, 1.446e-04, 1.842e-04, 2.239e-04,\n", + " 3.090e-04, 3.941e-04, 4.793e-04, 5.644e-04, 6.495e-04, 8.358e-04,\n", + " 1.022e-03, 1.208e-03, 1.395e-03, 1.581e-03, 1.767e-03, 2.185e-03,\n", + " 2.602e-03, 2.895e-03, 3.189e-03, 3.398e-03, 3.567e-03, 3.736e-03,\n", + " 3.905e-03, 4.038e-03, 4.171e-03, 4.304e-03, 4.438e-03, 4.571e-03,\n", + " 4.704e-03, 4.849e-03, 4.993e-03, 5.138e-03, 5.283e-03, 5.427e-03,\n", + " 5.572e-03, 5.832e-03, 6.093e-03, 6.353e-03, 6.613e-03, 6.874e-03,\n", + " 7.332e-03, 7.790e-03, 8.248e-03, 8.706e-03, 9.407e-03, 1.011e-02,\n", + " 1.081e-02, 1.151e-02, 1.273e-02, 1.396e-02, 1.519e-02, 1.641e-02,\n", + " 1.848e-02, 2.055e-02, 2.195e-02, 2.335e-02, 2.476e-02, 2.616e-02,\n", + " 2.857e-02, 3.097e-02, 3.218e-02, 3.338e-02, 3.458e-02, 3.578e-02,\n", + " 3.699e-02, 3.949e-02, 4.116e-02, 4.283e-02, 4.450e-02, 4.616e-02,\n", + " 5.025e-02, 5.433e-02, 5.842e-02, 6.250e-02, 6.937e-02, 7.624e-02,\n", + " 7.709e-02, 7.795e-02, 7.881e-02, 7.967e-02, 8.006e-02, 8.045e-02,\n", + " 8.084e-02, 8.182e-02, 8.280e-02, 8.378e-02, 8.420e-02, 8.462e-02,\n", + " 8.503e-02, 8.548e-02, 8.593e-02, 8.620e-02, 8.646e-02, 8.712e-02,\n", + " 8.778e-02, 9.300e-02, 9.822e-02, 1.096e-01, 1.110e-01, 1.124e-01,\n", + " 1.138e-01, 1.144e-01, 1.150e-01, 1.156e-01, 1.171e-01, 1.185e-01,\n", + " 1.200e-01, 1.208e-01, 1.216e-01, 1.224e-01, 1.229e-01, 1.233e-01,\n", + " 1.236e-01, 1.239e-01, 1.255e-01, 1.262e-01, 1.270e-01, 1.328e-01,\n", + " 1.386e-01, 1.519e-01, 1.652e-01, 1.668e-01, 1.685e-01, 1.702e-01,\n", + " 1.717e-01, 1.733e-01, 1.842e-01, 1.856e-01, 1.870e-01, 1.878e-01,\n", + " 1.886e-01, 1.891e-01, 1.896e-01, 1.899e-01, 1.902e-01, 1.933e-01,\n", + " 1.965e-01, 2.170e-01, 2.375e-01, 2.581e-01, 2.592e-01, 2.603e-01,\n", + " 2.614e-01, 2.723e-01, 2.832e-01, 3.164e-01, 3.496e-01, 3.828e-01,\n", + " 4.503e-01, 5.178e-01, 5.852e-01, 6.527e-01, 7.282e-01, 8.037e-01,\n", + " 8.791e-01, 9.546e-01, 1.105e+00, 1.256e+00, 1.406e+00, 1.557e+00,\n", + " 1.810e+00, 2.063e+00, 2.317e+00, 2.570e+00, 3.003e+00, 3.436e+00,\n", + " 3.869e+00, 4.302e+00, 4.915e+00, 5.528e+00, 6.142e+00, 6.755e+00,\n", + " 7.995e+00, 9.236e+00, 1.048e+01, 1.172e+01, 1.341e+01, 1.511e+01,\n", + " 1.680e+01, 1.850e+01, 2.118e+01, 2.386e+01, 2.654e+01, 2.923e+01,\n", + " 3.427e+01, 3.932e+01, 4.437e+01, 4.942e+01, 5.000e+01])" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -640,7 +778,11 @@ { "cell_type": "markdown", "id": "c14d81b0", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "The tracked time-series data can be exported to a file in two ways." ] @@ -649,7 +791,11 @@ "cell_type": "code", "execution_count": 13, "id": "c126483f", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# sys.scope.export('bsm1_time_series.xlsx')\n", @@ -667,16 +813,24 @@ { "cell_type": "markdown", "id": "5b93411d", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "We can also (re-)define which unit or stream to track during dynamic simulation." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "b818bfbf", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -684,7 +838,7 @@ "(, )" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -699,15 +853,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "f6b35327", "metadata": { - "scrolled": false + "scrolled": false, + "slideshow": { + "slide_type": "slide" + } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -724,15 +881,18 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "68dcbad5", "metadata": { - "scrolled": false + "scrolled": false, + "slideshow": { + "slide_type": "slide" + } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -748,27 +908,55 @@ { "cell_type": "markdown", "id": "0eb92bf1", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "So far we've learned how to simulate any dynamic system developed with QSDsan. \n", - "A complete list of existing unit operations within QSDsan is available [here](https://qsdsan.readthedocs.io/en/latest/api/sanunits/_index.html). The column \"Dynamic\" indicates whether the unit is enabled for dynamic simulations. Any system composed of the enabled units can be simulated dynamically as we learned above.\n", - "\n", + "A complete list of existing unit operations within QSDsan is available [here](https://qsdsan.readthedocs.io/en/latest/api/sanunits/_index.html). The column \"Dynamic\" indicates whether the unit is enabled for dynamic simulations. Any system composed of the enabled units can be simulated dynamically as we learned above." + ] + }, + { + "cell_type": "markdown", + "id": "497d72b8", + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, + "source": [ "[Back to top](#top)" ] }, { "cell_type": "markdown", "id": "3d13e036", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### 1.2. When is a system \"dynamic\"?\n", + "It's ultimately the user's decision whether a system should be run dynamically. This section will cover the essentials to switch to the dynamic mode for system simulation." + ] + }, + { + "cell_type": "markdown", + "id": "94eab6a5", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ - "### 1.2. What makes a system \"dynamic\"?\n", - "It's ultimately the user's decision whether a system should be run dynamically. This section will cover the essentials to switch to the dynamic mode for system simulation.\n", - "\n", "#### `System.isdynamic` vs. `SanUnit.isdynamic` vs. `SanUnit.hasode` \n", "\n", "- Simply speaking, when the `.isdynamic == True`, the program will attempt dynamic simulation. Users can directly enable/disable the dynamic mode by setting the `isdynamic` property of a `System` object.\n", "\n", - "- The program will deduct the value of `.isdynamic` when it's not specified by users. `.isdynamic` is considered `True` in all cases except when `.isdynamic == False` for all units.\n", + "- The program will set the value of `.isdynamic` when it's not specified by users. `.isdynamic` is considered `True` in all cases except when `.isdynamic == False` for all units.\n", "\n", "- Setting `.isdynamic = True` does not gaurantee the unit can be simulated dynamically. Just like how the `_run` method must be defined for static simulation, a series of additional methods must be defined to enable dynamic simulation.\n", "\n", @@ -777,9 +965,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "c130f36f", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -792,7 +984,7 @@ " : True}" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -802,407 +994,14 @@ "{u: u.hasode for u in sys.units}" ] }, - { - "cell_type": "code", - "execution_count": 16, - "id": "b6a0612a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "\n", - "\n", - "\n", - "\n", - "M1Mixer:e->A1CSTR:c\n", - "\n", - "\n", - "\n", - " ws26\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "A1CSTR:c->A2CSTR:c\n", - "\n", - "\n", - "\n", - " ws11\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "A2CSTR:c->O1CSTR:c\n", - "\n", - "\n", - "\n", - " ws13\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O1CSTR:c->O2CSTR:c\n", - "\n", - "\n", - "\n", - " ws15\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O2CSTR:c->O3CSTR:c\n", - "\n", - "\n", - "\n", - " ws17\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O3CSTR:c->M1Mixer:c\n", - "\n", - "\n", - "\n", - " RWW\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O3CSTR:c->C1Flat bottom circular clarifier:c\n", - "\n", - "\n", - "\n", - " treated\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "C1Flat bottom circular clarifier:c->M1Mixer:c\n", - "\n", - "\n", - "\n", - " RAS\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "C1Flat bottom circular clarifier:c->J1ASMto ADM:c\n", - "\n", - "\n", - "\n", - " WAS\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "C1Flat bottom circular clarifier:c-> effluent:w\n", - "\n", - "\n", - " effluent\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "J1ASMto ADM:c->AD1Anaerobic CSTR:c\n", - "\n", - "\n", - "\n", - " ws21\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "AD1Anaerobic CSTR:c->J2ADMto ASM:c\n", - "\n", - "\n", - "\n", - " ad eff\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "AD1Anaerobic CSTR:c-> biogas:w\n", - "\n", - "\n", - " biogas\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "J2ADMto ASM:c->M1Mixer:c\n", - "\n", - "\n", - "\n", - " ws25\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " wastewater:e->M1Mixer:c\n", - "\n", - "\n", - " wastewater\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " filler0:e->A1CSTR:c\n", - "\n", - "\n", - " filler0\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " filler1:e->A1CSTR:c\n", - "\n", - "\n", - " filler1\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "M1Mixer\n", - "\n", - "\n", - "M1Mixer\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "A1CSTR\n", - "\n", - "\n", - "A1CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "A2CSTR\n", - "\n", - "\n", - "A2CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O1CSTR\n", - "\n", - "\n", - "O1CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O2CSTR\n", - "\n", - "\n", - "O2CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "O3CSTR\n", - "\n", - "\n", - "O3CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "C1Flat bottom circular clarifier\n", - "\n", - "\n", - "C1Flat bottom circular clarifier\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "J1ASMto ADM\n", - "\n", - "\n", - "J1ASMto ADM\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "AD1Anaerobic CSTR\n", - "\n", - "\n", - "AD1Anaerobic CSTR\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "J2ADMto ASM\n", - "\n", - "\n", - "J2ADMto ASM\n", - "\n", - "\n", - "\n", - "\n", - "\n", - " wastewater\n", - "\n", - "\n", - "\n", - "\n", - " effluent\n", - "\n", - "\n", - "\n", - "\n", - " biogas\n", - "\n", - "\n", - "\n", - "\n", - " filler0\n", - "\n", - "\n", - "\n", - "\n", - " filler1\n", - "\n", - "\n", - "\n", - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Units without ODEs can also be simulated dynamically as long as \n", - "# the fundamental methods are defined. Here is an example.\n", - "from exposan import interface as inter\n", - "inter.load()\n", - "inter.sys.diagram()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "f2a81479", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{: False,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : True,\n", - " : False,\n", - " : True,\n", - " : False}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "{u: u.hasode for u in inter.sys.units}\n", - "# inter.sys.isdynamic" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "be199e8d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\joy_c\\Dropbox\\PhD\\Research\\QSD\\codes_developing\\QSDsan\\qsdsan\\sanunits\\_junction.py:573: UserWarning: Ignored dissolved H2 or CH4.\n", - " warn('Ignored dissolved H2 or CH4.')\n" - ] - }, - { - "data": { - "text/plain": [ - "(,\n", - " ,\n", - " ,\n", - " ,\n", - " )" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "uf = inter.sys.flowsheet.unit\n", - "inter.sys.simulate(t_span=(0,3), method='BDF', state_reset_hook='reset_cache')\n", - "inter.sys.scope.subjects" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "ff2ea29e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = uf.AD1.scope.plot_time_series(('S_ch4_gas', 'S_h2_gas', 'S_IC_gas'))" - ] - }, { "cell_type": "markdown", "id": "7839f0e2", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -1210,7 +1009,11 @@ { "cell_type": "markdown", "id": "33a3d638", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## 2. Writing a dynamic `SanUnit` \n", "\n", @@ -1220,7 +1023,11 @@ { "cell_type": "markdown", "id": "220c984a", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "### 2.1. Basic structure \n", "\n", @@ -1228,39 +1035,57 @@ "\n", "In comparison, during dynamic simulations, all information are stored as `_state` and `_dstate` attributes of the relevant `SanUnit` obejcts as well as `state` and `dstate` properties of `WasteStream` objects. These information won't be translated to mass or energy flows until dynamic simulation is completed.\n", "\n", - "- `WasteStream.state` is a 1d `numpy.array` of length $n+1$, $n$ is the length of the components associated with the `thermo`. Each element of the array represents value of one state variable.\n", + "- `WasteStream.state` is a 1d `numpy.array` of length $n+1$, $n$ is the length of the components associated with the `thermo`. Each element of the array represents value of one state variable." + ] + }, + { + "cell_type": "markdown", + "id": "b1529db3", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "---\n", + "#### Tip\n", "\n", - " ---\n", - " #### Tip\n", - " \n", - " Typically for a liquid `WasteStream`, the first $n$ element represents the component concentrations \\[mg/L\\], while the last element represents the total volumetric flow \\[m3/d\\]. For a gaseous `WasteStream`, the first $n$ state variables can simply be the mass flows \\[g/d\\] of the components if the last element is fixed at 1. This is because after completing dynamic simulations, the `WasteStream`'s mass flow is defined as the first $n$ element of this array multiplied by the last element.\n", + "Typically for a liquid `WasteStream`, the first $n$ element represents the component concentrations \\[mg/L\\], while the last element represents the total volumetric flow \\[m3/d\\]. For a gaseous `WasteStream`, the first $n$ state variables can simply be the mass flows \\[g/d\\] of the components if the last element is fixed at 1. This is because after completing dynamic simulations, the `WasteStream`'s mass flow is defined as the first $n$ element of this array multiplied by the last element.\n", "\n", - " ---" + "---" ] }, { "cell_type": "markdown", "id": "d997b05d", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "- `WasteStrem.dstate` is an array of the exact same shape as `WasteStream.state`, storing values of the time derivatives (i.e., the rates of change) of the state variables." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "id": "a8ae235a", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ "array([3.000e+01, 8.899e-01, 4.389e+00, 1.886e-01, 9.784e+00, 5.720e-01,\n", - " 1.722e+00, 4.898e-01, 1.038e+01, 1.747e+00, 6.884e-01, 1.349e-02,\n", - " 4.954e+01, 2.751e+01, 9.986e+05, 1.806e+04])" + " 1.722e+00, 4.897e-01, 1.038e+01, 1.747e+00, 6.884e-01, 1.349e-02,\n", + " 4.954e+01, 2.751e+01, 9.978e+05, 1.806e+04])" ] }, - "execution_count": 20, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1272,19 +1097,23 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "id": "ab1496fd", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ "sparse([3.000e+01, 8.899e-01, 4.389e+00, 1.886e-01, 9.784e+00, 5.720e-01,\n", - " 1.722e+00, 4.898e-01, 1.038e+01, 1.747e+00, 6.884e-01, 1.349e-02,\n", - " 4.954e+01, 2.751e+01, 9.988e+05])" + " 1.722e+00, 4.897e-01, 1.038e+01, 1.747e+00, 6.884e-01, 1.349e-02,\n", + " 4.954e+01, 2.751e+01, 9.981e+05])" ] }, - "execution_count": 21, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1296,9 +1125,13 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "id": "825050c1", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -1306,7 +1139,7 @@ "True" ] }, - "execution_count": 22, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1318,8 +1151,13 @@ { "cell_type": "markdown", "id": "eb706d47", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ + "\n", "- `SanUnit._state` is also a 1d `numpy.array`, but the length of the array is not assumed, because the state variables relevant for a `SanUnit` is entirely dependent on the unit operation itself. Therefore, there is no predefined units of measure or order for state variables of a unit operation.\n", "\n", "- `SanUnit._dstate`, similarly, must have the exact same shape as the `_state` array, as each element corresponds to the time derivative of a state variable." @@ -1327,9 +1165,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "id": "956dbc0f", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { @@ -1337,43 +1179,48 @@ "False" ] }, - "execution_count": 23, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "C1._state.shape == A1._state.shape" + "C1._state.shape == A1._state.shape\n", + "# C1._state.shape == C1._dstate.shape" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "id": "561a5589", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ "{'S_I': 30.0,\n", - " 'S_S': 2.8098364831332874,\n", - " 'X_I': 1147.9022739122495,\n", - " 'X_S': 82.1499821192233,\n", - " 'X_BH': 2551.1711914474663,\n", - " 'X_BA': 148.18618671733967,\n", - " 'X_P': 447.1254556866469,\n", - " 'S_O': 0.004289034729931556,\n", - " 'S_NO': 5.338805118093289,\n", - " 'S_NH': 7.929128379209027,\n", - " 'S_ND': 1.2166810265512678,\n", - " 'X_ND': 5.285761329880132,\n", - " 'S_ALK': 59.15859597894533,\n", - " 'S_N2': 25.007887255081272,\n", - " 'H2O': 998557.4809730583,\n", + " 'S_S': 2.8098296544615704,\n", + " 'X_I': 1147.8970757884535,\n", + " 'X_S': 82.14996504835973,\n", + " 'X_BH': 2551.1712941951987,\n", + " 'X_BA': 148.18576250649838,\n", + " 'X_P': 447.1086242830684,\n", + " 'S_O': 0.004288622012845044,\n", + " 'S_NO': 5.33892893863284,\n", + " 'S_NH': 7.928812844268634,\n", + " 'S_ND': 1.216680910568711,\n", + " 'X_ND': 5.285760801254182,\n", + " 'S_ALK': 59.158219028756534,\n", + " 'S_N2': 25.008073542375985,\n", + " 'H2O': 997794.331078558,\n", " 'Q': 92229.99999999996}" ] }, - "execution_count": 24, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1387,7 +1234,11 @@ { "cell_type": "markdown", "id": "68f067f1", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -1395,11 +1246,25 @@ { "cell_type": "markdown", "id": "b6a928f2", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "### 2.2. Fundamental methods\n", - "In addition to proper `__init__` and `_run` methods ([recap](https://qsdsan.readthedocs.io/en/latest/tutorials/5_SanUnit_advanced.html#2.1.-Fundamental-methods)), a few more methods are required in a `SanUnit` subclass for dynamic simulation. Users typically won't interact with these methods but they will be called by `System.simulate` to manipulate the values of the arrays mentioned [above](#s2.1) (i.e., `._state`, `._dstate`, `.state`, and `.dstate`).\n", - "\n", + "In addition to proper `__init__` and `_run` methods ([recap](https://qsdsan.readthedocs.io/en/latest/tutorials/5_SanUnit_advanced.html#2.1.-Fundamental-methods)), a few more methods are required in a `SanUnit` subclass for dynamic simulation. Users typically won't interact with these methods but they will be called by `System.simulate` to manipulate the values of the arrays mentioned [above](#s2.1) (i.e., `._state`, `._dstate`, `.state`, and `.dstate`)." + ] + }, + { + "cell_type": "markdown", + "id": "976dabeb", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "- `_init_state`, called after `_run` to generate an initial condition for the unit, i.e., defining shape and values of the `_state` and `_dstate` arrays. For example:\n", "```python\n", "import numpy as np\n", @@ -1408,9 +1273,18 @@ " self._state = np.ones(len(inf.components)+1)\n", " self._dstate = self._state * 0.\n", "```\n", - "This method (not saying it makes sense) assumes $n+1$ state variables and gives an initial value of 1 to all of them. Then it also sets the initial time derivatives to be 0. \n", - "\n", - "\n", + "This method (not saying it makes sense) assumes $n+1$ state variables and gives an initial value of 1 to all of them. Then it also sets the initial time derivatives to be 0. " + ] + }, + { + "cell_type": "markdown", + "id": "3a3de71d", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "- `_update_state`, to update effluent streams' state arrays based on current state (and maybe dstate) of the SanUnit. For example:\n", "```python\n", "def _update_state(self):\n", @@ -1418,8 +1292,18 @@ " eff, = self.outs # assuming this SanUnit has one outlet only\n", " eff.state[:] = arr # assume arr has the same shape as WasteStream.state\n", "```\n", - "The goal of this method is to update the values in `.state` for each `WasteStream` in `.outs`.\n", - "\n", + "The goal of this method is to update the values in `.state` for each `WasteStream` in `.outs`." + ] + }, + { + "cell_type": "markdown", + "id": "8deec2a2", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "- `_update_dstate`, to update effluent streams' `dstate` arrays based on current `_state` and `_dstate` of the SanUnit. The signiture and often the algorithm are similar to `_update_state`.\n", "\n", "\n", @@ -1430,7 +1314,18 @@ " if self._ODE is None:\n", " self._compile_ODE()\n", " return self._ODE \n", - "```\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "a431142f", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "```python\n", "def _compile_ODE(self):\n", " _dstate = self._dstate\n", @@ -1439,14 +1334,36 @@ " _dstate[:] = some_algorithm(t, y_ins, y, dy_ins)\n", " _update_dstate()\n", " self._ODE = dy_dt\n", - "```\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "83c50a89", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "```python\n", "@property\n", "def AE(self):\n", " if self._AE is None:\n", " self._compile_AE()\n", " return self._AE\n", - "```\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "dd66c263", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "```python\n", "def _compile_AE(self):\n", " _state = self._state\n", @@ -1459,8 +1376,18 @@ " _update_state()\n", " _update_dstate()\n", " self._AE = y_t\n", - "```\n", - "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "a144502d", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "> **Note**: Within the `dy_dt` or `y_t` functions, `._state[:] = ` rather than `._state = ` because it's generally faster to update values in an existing array than overwriting this array with a newly created array.\n", "\n", "We'll learn more about these two methods in the next subsections." @@ -1469,7 +1396,11 @@ { "cell_type": "markdown", "id": "7cb3c766", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -1477,7 +1408,11 @@ { "cell_type": "markdown", "id": "afd475f2", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "### 2.3. Making a simple MixerSplitter (`_compile_AE`)\n", "\n", @@ -1486,9 +1421,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "id": "c38b235a", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# Typically if implemented as a static SanUnit, it'd be pretty simple\n", @@ -1520,9 +1459,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 24, "id": "9b5ce52d", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "name": "stdout", @@ -1540,34 +1483,37 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 25, "id": "12aa03d9", "metadata": { - "scrolled": false + "scrolled": false, + "slideshow": { + "slide_type": "slide" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WasteStream: ws28\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_S 3e+03\n", - " S_NH 2.1e+03\n", - " H2O 8e+05\n", + "WasteStream: ws12\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_S 3e+03\n", + " S_NH 2.1e+03\n", + " H2O 8e+05\n", " WasteStream-specific properties:\n", " pH : 7.0\n", " Alkalinity : 2.5 mg/L\n", - " COD : 3711.6 mg/L\n", - " BOD : 2661.2 mg/L\n", - " TC : 1187.7 mg/L\n", - " TOC : 1187.7 mg/L\n", - " TN : 2598.1 mg/L\n", + " COD : 3711.8 mg/L\n", + " BOD : 2661.3 mg/L\n", + " TC : 1187.8 mg/L\n", + " TOC : 1187.8 mg/L\n", + " TN : 2598.2 mg/L\n", " TP : 37.1 mg/L\n", " Component concentrations (mg/L):\n", - " S_S 3711.6\n", - " S_NH 2598.1\n", - " H2O 989764.3\n" + " S_S 3711.8\n", + " S_NH 2598.2\n", + " H2O 989803.5\n" ] } ], @@ -1580,79 +1526,82 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 26, "id": "4ff4c667", "metadata": { - "scrolled": true + "scrolled": true, + "slideshow": { + "slide_type": "slide" + } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MixerSplitter1: M2\n", + "MixerSplitter1: M1\n", "ins...\n", - "[0] ws27\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_O 5e+03\n", - " H2O 1e+06\n", + "[0] ws11\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_O 5e+03\n", + " H2O 1e+06\n", " WasteStream-specific properties:\n", " pH : 7.0\n", - "[1] ws28\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_S 3e+03\n", - " S_NH 2.1e+03\n", - " H2O 8e+05\n", + "[1] ws12\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_S 3e+03\n", + " S_NH 2.1e+03\n", + " H2O 8e+05\n", " WasteStream-specific properties:\n", " pH : 7.0\n", - " COD : 3711.6 mg/L\n", - " BOD : 2661.2 mg/L\n", - " TC : 1187.7 mg/L\n", - " TOC : 1187.7 mg/L\n", - " TN : 2598.1 mg/L\n", + " COD : 3711.8 mg/L\n", + " BOD : 2661.3 mg/L\n", + " TC : 1187.8 mg/L\n", + " TOC : 1187.8 mg/L\n", + " TN : 2598.2 mg/L\n", " TP : 37.1 mg/L\n", "outs...\n", - "[0] ws29\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_S 1e+03\n", - " S_O 1.67e+03\n", - " S_NH 700\n", - " H2O 6e+05\n", + "[0] ws13\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_S 1e+03\n", + " S_O 1.67e+03\n", + " S_NH 700\n", + " H2O 6e+05\n", " WasteStream-specific properties:\n", " pH : 7.0\n", - " COD : 1645.9 mg/L\n", - " BOD : 1180.1 mg/L\n", - " TC : 526.7 mg/L\n", - " TOC : 526.7 mg/L\n", - " TN : 1152.1 mg/L\n", + " COD : 1650.8 mg/L\n", + " BOD : 1183.6 mg/L\n", + " TC : 528.3 mg/L\n", + " TOC : 528.3 mg/L\n", + " TN : 1155.6 mg/L\n", " TP : 16.5 mg/L\n", - "[1] ws30\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_S 1e+03\n", - " S_O 1.67e+03\n", - " S_NH 700\n", - " H2O 6e+05\n", + "[1] ws14\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_S 1e+03\n", + " S_O 1.67e+03\n", + " S_NH 700\n", + " H2O 6e+05\n", " WasteStream-specific properties:\n", " pH : 7.0\n", - " COD : 1645.9 mg/L\n", - " BOD : 1180.1 mg/L\n", - " TC : 526.7 mg/L\n", - " TOC : 526.7 mg/L\n", - " TN : 1152.1 mg/L\n", + " COD : 1650.8 mg/L\n", + " BOD : 1183.6 mg/L\n", + " TC : 528.3 mg/L\n", + " TOC : 528.3 mg/L\n", + " TN : 1155.6 mg/L\n", " TP : 16.5 mg/L\n", - "[2] ws31\n", - " phase: 'l', T: 298.15 K, P: 101325 Pa\n", - " flow (g/hr): S_S 1e+03\n", - " S_O 1.67e+03\n", - " S_NH 700\n", - " H2O 6e+05\n", + "[2] ws15\n", + "phase: 'l', T: 298.15 K, P: 101325 Pa\n", + "flow (g/hr): S_S 1e+03\n", + " S_O 1.67e+03\n", + " S_NH 700\n", + " H2O 6e+05\n", " WasteStream-specific properties:\n", " pH : 7.0\n", - " COD : 1645.9 mg/L\n", - " BOD : 1180.1 mg/L\n", - " TC : 526.7 mg/L\n", - " TOC : 526.7 mg/L\n", - " TN : 1152.1 mg/L\n", + " COD : 1650.8 mg/L\n", + " BOD : 1183.6 mg/L\n", + " TC : 528.3 mg/L\n", + " TOC : 528.3 mg/L\n", + " TN : 1155.6 mg/L\n", " TP : 16.5 mg/L\n" ] } @@ -1665,9 +1614,14 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 27, "id": "72151a1e", - "metadata": {}, + "metadata": { + "scrolled": true, + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# Obviously, it's not ready for dynamic simulation\n", @@ -1679,30 +1633,59 @@ { "cell_type": "markdown", "id": "0c4eb0cd", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "Since the mixer-splitter mixes and splits instantly, we can express this process with a set of algebraic equations (AEs). Assume its array of state variables follow the \"concentration-volumetric flow\" convention. In mathematical forms, state variables of the mixer-splitter ($C_m$, component concentrations; $Q_m$, total volumetric flow) follow:\n", "$$Q_m = \\sum_{i \\in ins} Q_i \\tag{1}$$\n", "$$Q_mC_m = \\sum_{i \\in ins} Q_iC_i$$\n", - "$$\\therefore C_m = \\frac{\\sum_{i \\in ins} Q_iC_i}{Q_m} \\tag{2}$$\n", + "$$\\therefore C_m = \\frac{\\sum_{i \\in ins} Q_iC_i}{Q_m} \\tag{2}$$" + ] + }, + { + "cell_type": "markdown", + "id": "a37f98d9", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "Therefore, the time derivatives $\\dot{Q_m}$ follow:\n", "$$\\dot{Q_m} = \\sum_{i \\in ins} \\dot{Q_i} \\tag{3}$$\n", "$$Q_m\\dot{C_m} + C_m\\dot{Q_m} = \\sum_{i \\in ins} (Q_i\\dot{C_i} + C_i\\dot{Q_i})$$\n", - "$$\\therefore \\dot{C_m} = \\frac{1}{Q_m}\\cdot(\\sum_{i \\in ins}Q_i\\dot{C_i} + \\sum_{i \\in ins}C_i\\dot{Q_i} - C_m\\dot{Q_m}) \\tag{4}$$\n", + "$$\\therefore \\dot{C_m} = \\frac{1}{Q_m}\\cdot(\\sum_{i \\in ins}Q_i\\dot{C_i} + \\sum_{i \\in ins}C_i\\dot{Q_i} - C_m\\dot{Q_m}) \\tag{4}$$" + ] + }, + { + "cell_type": "markdown", + "id": "7578a12e", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "For any effluent `WasteStream` $j$:\n", "$$Q_j = \\frac{Q_m}{n_{outs}} \\tag{5}$$\n", "$$C_j = C_m \\tag{6}$$\n", "$$\\therefore \\dot{Q_j} = \\frac{\\dot{Q_m}}{n_{outs}} \\tag{7}$$\n", "$$\\dot{C_j} = \\dot{C_m} \\tag{8}$$\n", - "Now, let's try to implement this algorithm in methods for dynamic simulation.\n", - "\n" + "Now, let's try to implement this algorithm in methods for dynamic simulation." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "id": "38abf7cb", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "import numpy as np\n", @@ -1758,7 +1741,11 @@ { "cell_type": "markdown", "id": "da258438", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ ">**Note**: \n", ">1. All `SanUnit._AE` must take exactly these three postional arguments (`t`, `y_ins`, `dy_ins`). `t` is time as a `float`. Both `y_ins` and `dy_ins` are **2d** `numpy.array` of the same shape `(m, n+1)`, where $m$ is the number of inlets, $n+1$ is the length of the `state` or `dstate` array of a `WasteStream`.\n", @@ -1768,9 +1755,13 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "id": "ba8c9001", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# Now let's see if this works\n", @@ -1782,13 +1773,17 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "id": "a4f65bf6", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1806,7 +1801,11 @@ { "cell_type": "markdown", "id": "22788b98", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "Many commonly used unit operations, such as [Pump](https://qsdsan.readthedocs.io/en/latest/api/sanunits/pumping.html#qsdsan.sanunits.Pump), [Mixer](https://qsdsan.readthedocs.io/en/latest/api/sanunits/abstract.html#mixer), [Splitter](https://qsdsan.readthedocs.io/en/latest/api/sanunits/abstract.html#splitter), and [HydraulicDelay](https://qsdsan.readthedocs.io/en/latest/api/sanunits/pumping.html#hydraulicdelay), have implemented the fundamental methods to be used in a dynamic system. You can always refer to the source codes of these units to learn more about how they work." ] @@ -1814,7 +1813,11 @@ { "cell_type": "markdown", "id": "1f5d8d3f", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -1822,7 +1825,11 @@ { "cell_type": "markdown", "id": "a04a8ab5", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "### 2.4. Making an inactive CompleteMixTank (`_compile_ODE`)" ] @@ -1830,7 +1837,11 @@ { "cell_type": "markdown", "id": "21dca6ff", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "As you can see above, it's not very impressive to dynamically simulate a system without any ODEs. So let's make a simple inactive complete mix tank. Assume the reactor has a fixed liquid volume $V$, and thus the effluent volumetric flow rate changes instantly with influents. The mass balance of this type of reactor can be described as:\n", "$$Q = \\sum_{i \\in ins} Q_i \\tag{9}$$\n", @@ -1842,9 +1853,13 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "id": "c4706ed2", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "class CompleteMixTank(qs.SanUnit):\n", @@ -1908,7 +1923,11 @@ { "cell_type": "markdown", "id": "472f1577", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ ">**Note**: \n", ">1. All `SanUnit._ODE` must take exactly these four postional arguments: `t`, `y_ins`, and `dy_ins` are the same as the ones in `SanUnit._AE`. `y` is a **1d** `numpy.array`, because it is equal to the `_state` array of the unit.\n", @@ -1918,9 +1937,13 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "id": "493239c1", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# Let's see if it works\n", @@ -1937,24 +1960,28 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "id": "c3df8f02", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, - "execution_count": 34, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1970,7 +1997,11 @@ { "cell_type": "markdown", "id": "3970aeaa", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "Many commonly used unit operations described by ODEs have been implemented in QSDsan, such as [CSTR](https://qsdsan.readthedocs.io/en/latest/api/sanunits/suspended_growth_bioreactors.html#cstr), [BatchExperiment](https://qsdsan.readthedocs.io/en/latest/api/sanunits/suspended_growth_bioreactors.html#batchexperiment), and [FlatBottomCircularClarifier](https://qsdsan.readthedocs.io/en/latest/api/sanunits/clarifiers.html)." ] @@ -1978,7 +2009,11 @@ { "cell_type": "markdown", "id": "9d9a485a", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -1986,7 +2021,11 @@ { "cell_type": "markdown", "id": "b085b491", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## 3. Other convenient features \n", "### 3.1. `ExogenousDynamicVariable`\n", @@ -1995,42 +2034,75 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "id": "6e8b6a32", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# Check out the documentation\n", "from qsdsan.utils import ExogenousDynamicVariable as EDV\n", - "EDV?" + "# EDV?" ] }, { "cell_type": "markdown", "id": "d0365c64", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "There are generally two ways to create an `ExogenousDynamicVariable`.\n", "\n", "1. __Define the variable as a function of time.__ Let's say we want to create a variable to represent the changing reaction temperature. Assume the temperature value \\[K\\] can be expressed as $T = 298.15 + 5\\cdot \\sin(t)$, indicating that the temperatue fluctuacts around $25^{\\circ}C$ by $\\pm 5^{\\circ}C$. Then simply,\n", "```python\n", "T = EDV('T', function=lambda t: 298.15+5*np.sin(t))\n", - "```\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "e2885b32", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "2. __Provide time-series data to describe the dynamics of the variable.__ For demonstration purpose, we'll just make up the data. In practice, this is convenient if you have real data.\n", "```python\n", "t_arr = np.linspace(0, 5)\n", "y_arr = 298.15+5*np.sin(t_arr)\n", "T = EDV('T', t=t_arr, y=y_arr)\n", - "```\n", - "\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "a89fa738", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ "For convenience, `ExogenousDynamicVariable` also has a `classmethod` that enables batch creation of multiple variables at once. We just need to provide a file of the time-series data, including a column `t` for time points and additional columns of the variable values. See the [documentation](https://qsdsan.readthedocs.io/en/latest/api/utils/dynamics.html#qsdsan.utils.ExogenousDynamicVariable.batch_init) of `ExogenousDynamicVariable.batch_init` for detailed usage." ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 35, "id": "b6401d1c", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "# EDV.batch_init?" @@ -2039,7 +2111,11 @@ { "cell_type": "markdown", "id": "8a5bd5b7", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "Once created, these `ExogenousDynamicVariable` objects can be incorporated into any `SanUnit` upon its initialization or through the `SanUnit.exo_dynamic_vars` property setter. " ] @@ -2048,12 +2124,24 @@ "cell_type": "code", "execution_count": 36, "id": "2639a8b7", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All impact indicators have been removed from the registry.\n", + "All impact items have been removed from the registry.\n" + ] + }, { "data": { "text/plain": [ - "(, )" + "(,)" ] }, "execution_count": 36, @@ -2063,22 +2151,26 @@ ], "source": [ "# Let's see an example\n", - "from exposan.metab_mock import create_systems\n", - "sys_mt, = create_systems(which='A')\n", + "from exposan.metab import create_system\n", + "sys_mt = create_system()\n", "uf_mt = sys_mt.flowsheet.unit\n", - "uf_mt.R1A.exo_dynamic_vars" + "uf_mt.R1.exo_dynamic_vars" ] }, { "cell_type": "code", "execution_count": 37, "id": "a7e11837", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ - "[308.15, 5.8]" + "[295.15]" ] }, "execution_count": 37, @@ -2089,13 +2181,17 @@ "source": [ "# The evaluation of these variables during unit simulation is done through \n", "# the `eval_exo_dynamic_vars` method\n", - "uf_mt.R1A.eval_exo_dynamic_vars(t=0.1)" + "uf_mt.R1.eval_exo_dynamic_vars(t=0.1)" ] }, { "cell_type": "markdown", "id": "0d1b7290", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] @@ -2103,7 +2199,11 @@ { "cell_type": "markdown", "id": "d8205f55", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "### 3.2. `DynamicInfluent`\n", "The [DynamicInfluent](https://qsdsan.readthedocs.io/en/latest/api/sanunits/DynamicInfluent.html) is a `SanUnit` subclass for generating dynamic influent streams from user-defined time-series data. The use of this class is, to some extent, similar to an `ExogenousDynamicVariable`." @@ -2113,7 +2213,11 @@ "cell_type": "code", "execution_count": 38, "id": "3ea577e7", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [], "source": [ "from qsdsan.sanunits import DynamicInfluent as DI\n", @@ -2124,13 +2228,18 @@ "cell_type": "code", "execution_count": 39, "id": "7c2c9521", - "metadata": {}, + "metadata": { + "scrolled": false, + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "data": { "text/plain": [ "(
,\n", - " )" + " )" ] }, "execution_count": 39, @@ -2139,7 +2248,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2160,13 +2269,18 @@ { "cell_type": "markdown", "id": "786d6034", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "skip" + } + }, "source": [ "[Back to top](#top)" ] } ], "metadata": { + "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", diff --git a/docs/source/tutorials/12_Anaerobic_Digestion_Model_No_1.ipynb b/docs/source/tutorials/12_Anaerobic_Digestion_Model_No_1.ipynb index 4375a072..ca9f713e 100644 --- a/docs/source/tutorials/12_Anaerobic_Digestion_Model_No_1.ipynb +++ b/docs/source/tutorials/12_Anaerobic_Digestion_Model_No_1.ipynb @@ -17,13 +17,7 @@ " - [2. System Setup](#s2)\n", " - [3. System Simulation](#s3)\n", " \n", - "- **Video demo:**\n", - "\n", - " - To be posted\n", - " \n", - "To run tutorials in your browser, go to this [Binder page](https://mybinder.org/v2/gh/QSD-Group/QSDsan/main?filepath=%2Fdocs%2Fsource%2Ftutorials).\n", - " \n", - "You can also watch a video demo on YouTube (link to be posted) (subscriptions & likes appreciated!)." + "To run tutorials in your browser, go to this [Binder page](https://mybinder.org/v2/gh/QSD-Group/QSDsan/main?filepath=%2Fdocs%2Fsource%2Ftutorials)." ] }, { @@ -36,7 +30,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "This tutorial was made with qsdsan v1.3.0 and exposan v1.3.0\n" + "This tutorial was made with qsdsan v1.3.1 and exposan v1.3.1\n" ] } ], @@ -179,769 +173,6 @@ "adm1.show() # 22 processes in ADM1" ] }, - { - "cell_type": "code", - "execution_count": 5, - "id": "cc34c5f3", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'disintegration': ,\n", - " 'hydrolysis_carbs': ,\n", - " 'hydrolysis_proteins': ,\n", - " 'hydrolysis_lipids': ,\n", - " 'uptake_sugars': ,\n", - " 'uptake_amino_acids': ,\n", - " 'uptake_LCFA': ,\n", - " 'uptake_valerate': ,\n", - " 'uptake_butyrate': ,\n", - " 'uptake_propionate': ,\n", - " 'uptake_acetate': ,\n", - " 'uptake_h2': ,\n", - " 'decay_Xsu': ,\n", - " 'decay_Xaa': ,\n", - " 'decay_Xfa': ,\n", - " 'decay_Xc4': ,\n", - " 'decay_Xpro': ,\n", - " 'decay_Xac': ,\n", - " 'decay_Xh2': ,\n", - " 'h2_transfer': ,\n", - " 'ch4_transfer': ,\n", - " 'IC_transfer': ,\n", - " 'tuple': (,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ),\n", - " 'size': 22,\n", - " 'IDs': ('disintegration',\n", - " 'hydrolysis_carbs',\n", - " 'hydrolysis_proteins',\n", - " 'hydrolysis_lipids',\n", - " 'uptake_sugars',\n", - " 'uptake_amino_acids',\n", - " 'uptake_LCFA',\n", - " 'uptake_valerate',\n", - " 'uptake_butyrate',\n", - " 'uptake_propionate',\n", - " 'uptake_acetate',\n", - " 'uptake_h2',\n", - " 'decay_Xsu',\n", - " 'decay_Xaa',\n", - " 'decay_Xfa',\n", - " 'decay_Xc4',\n", - " 'decay_Xpro',\n", - " 'decay_Xac',\n", - " 'decay_Xh2',\n", - " 'h2_transfer',\n", - " 'ch4_transfer',\n", - " 'IC_transfer'),\n", - " '_index': {'disintegration': 0,\n", - " 'hydrolysis_carbs': 1,\n", - " 'hydrolysis_proteins': 2,\n", - " 'hydrolysis_lipids': 3,\n", - " 'uptake_sugars': 4,\n", - " 'uptake_amino_acids': 5,\n", - " 'uptake_LCFA': 6,\n", - " 'uptake_valerate': 7,\n", - " 'uptake_butyrate': 8,\n", - " 'uptake_propionate': 9,\n", - " 'uptake_acetate': 10,\n", - " 'uptake_h2': 11,\n", - " 'decay_Xsu': 12,\n", - " 'decay_Xaa': 13,\n", - " 'decay_Xfa': 14,\n", - " 'decay_Xc4': 15,\n", - " 'decay_Xpro': 16,\n", - " 'decay_Xac': 17,\n", - " 'decay_Xh2': 18,\n", - " 'h2_transfer': 19,\n", - " 'ch4_transfer': 20,\n", - " 'IC_transfer': 21},\n", - " '_components': CompiledComponents([S_su, S_aa, S_fa, S_va, S_bu, S_pro, S_ac, S_h2, S_ch4, S_IC, S_IN, S_I, X_c, X_ch, X_pr, X_li, X_su, X_aa, X_fa, X_c4, X_pro, X_ac, X_h2, X_I, S_cat, S_an, H2O]),\n", - " '_parameters': {'f_ch_xc': 0.2,\n", - " 'f_pr_xc': 0.2,\n", - " 'f_li_xc': 0.3,\n", - " 'f_xI_xc': 0.2,\n", - " 'f_sI_xc': 0.10000000000000009,\n", - " 'f_fa_li': 0.95,\n", - " 'f_bu_su': 0.13,\n", - " 'f_pro_su': 0.27,\n", - " 'f_ac_su': 0.41,\n", - " 'f_h2_su': 0.19,\n", - " 'f_va_aa': 0.23,\n", - " 'f_bu_aa': 0.26,\n", - " 'f_pro_aa': 0.05,\n", - " 'f_ac_aa': 0.4,\n", - " 'f_h2_aa': 0.06,\n", - " 'f_ac_fa': 0.7,\n", - " 'f_h2_fa': 0.30000000000000004,\n", - " 'f_pro_va': 0.54,\n", - " 'f_ac_va': 0.31,\n", - " 'f_h2_va': 0.14999999999999997,\n", - " 'f_ac_bu': 0.8,\n", - " 'f_h2_bu': 0.19999999999999996,\n", - " 'f_ac_pro': 0.57,\n", - " 'f_h2_pro': 0.43000000000000005,\n", - " 'Y_su': 0.1,\n", - " 'Y_aa': 0.08,\n", - " 'Y_fa': 0.06,\n", - " 'Y_c4': 0.06,\n", - " 'Y_pro': 0.04,\n", - " 'Y_ac': 0.05,\n", - " 'Y_h2': 0.06},\n", - " '_dyn_params': {},\n", - " '_stoichiometry': [[0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -0.375348450566896*f_ch_xc - 0.264038220398782*f_li_xc - 0.360321*f_pr_xc - 0.360321*f_sI_xc - 0.360321*f_xI_xc + 0.334618102,\n", - " -0.0980469*f_pr_xc - 0.0600327162*f_sI_xc - 0.0600327162*f_xI_xc + 0.0376219962,\n", - " 1.0*f_sI_xc,\n", - " -1.00000000000000,\n", - " 1.0*f_ch_xc,\n", - " 1.0*f_pr_xc,\n", - " 1.0*f_li_xc,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*f_xI_xc,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -5.55111512312578e-17,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [1.0 - 1.0*f_fa_li,\n", - " 0,\n", - " 1.0*f_fa_li,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.114236484955142*f_fa_li - 0.111310230168114,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [-1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*f_bu_su*(1 - Y_su),\n", - " 1.0*f_pro_su*(1 - Y_su),\n", - " 1.0*f_ac_su*(1 - Y_su),\n", - " 1.0*f_h2_su*(1 - Y_su),\n", - " 0,\n", - " 0.375348450566896*Y_su*f_ac_su + 0.300278760453517*Y_su*f_bu_su + 0.321727243343054*Y_su*f_pro_su - 0.37593491*Y_su - 0.375348450566896*f_ac_su - 0.300278760453517*f_bu_su - 0.321727243343054*f_pro_su + 0.375348450566896,\n", - " -0.08*Y_su,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_su,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 1.0*f_va_aa*(1 - Y_aa),\n", - " 1.0*f_bu_aa*(1 - Y_aa),\n", - " 1.0*f_pro_aa*(1 - Y_aa),\n", - " 1.0*f_ac_aa*(1 - Y_aa),\n", - " 1.0*f_h2_aa*(1 - Y_aa),\n", - " 0,\n", - " 0.375348450566896*Y_aa*f_ac_aa + 0.300278760453517*Y_aa*f_bu_aa + 0.321727243343054*Y_aa*f_pro_aa + 0.288729577359151*Y_aa*f_va_aa - 0.37593491*Y_aa - 0.375348450566896*f_ac_aa - 0.300278760453517*f_bu_aa - 0.321727243343054*f_pro_aa - 0.288729577359151*f_va_aa + 0.360321,\n", - " 0.0980469 - 0.08*Y_aa,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_aa,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*f_ac_fa*(1 - Y_fa),\n", - " 1.0*f_h2_fa*(1 - Y_fa),\n", - " 0,\n", - " 0.375348450566896*Y_fa*f_ac_fa - 0.37593491*Y_fa - 0.375348450566896*f_ac_fa + 0.261111965611754,\n", - " -0.08*Y_fa,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_fa,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 1.0*f_pro_va*(1 - Y_c4),\n", - " 1.0*f_ac_va*(1 - Y_c4),\n", - " 1.0*f_h2_va*(1 - Y_c4),\n", - " 0,\n", - " 0.375348450566896*Y_c4*f_ac_va + 0.321727243343054*Y_c4*f_pro_va - 0.37593491*Y_c4 - 0.375348450566896*f_ac_va - 0.321727243343054*f_pro_va + 0.288729577359151,\n", - " -0.08*Y_c4,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_c4,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 1.0*f_ac_bu*(1 - Y_c4),\n", - " 1.0*f_h2_bu*(1 - Y_c4),\n", - " 0,\n", - " 0.375348450566896*Y_c4*f_ac_bu - 0.37593491*Y_c4 - 0.375348450566896*f_ac_bu + 0.300278760453517,\n", - " -0.08*Y_c4,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_c4,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 1.0*f_ac_pro*(1 - Y_pro),\n", - " 1.0*f_h2_pro*(1 - Y_pro),\n", - " 0,\n", - " 0.375348450566896*Y_pro*f_ac_pro - 0.37593491*Y_pro - 0.375348450566896*f_ac_pro + 0.321727243343054,\n", - " -0.08*Y_pro,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_pro,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 1.0 - 1.0*Y_ac,\n", - " 0.187674225283448 - 0.188260684716552*Y_ac,\n", - " -0.08*Y_ac,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_ac,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 1.0 - 1.0*Y_h2,\n", - " -0.188260684716552*Y_h2 - 0.187674225283448,\n", - " -0.08*Y_h2,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 1.0*Y_h2,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0.0413168080000000,\n", - " 0.0423780038000000,\n", - " 0,\n", - " 1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.00000000000000,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0],\n", - " [0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " -1.0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0,\n", - " 0]],\n", - " '_stoichio_lambdified': None,\n", - " '_rate_equations': (None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None,\n", - " None),\n", - " '_production_rates': None,\n", - " '_rate_function': }" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "adm1.__dict__ # adm1 is composed of..." - ] - }, { "cell_type": "markdown", "id": "0b3d103f", @@ -952,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "9a9db08e", "metadata": {}, "outputs": [ @@ -1332,7 +563,7 @@ "[22 rows x 27 columns]" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -1368,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "a28bc7d2", "metadata": {}, "outputs": [], @@ -1381,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "28a9c8e5", "metadata": {}, "outputs": [], @@ -1394,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "bdd90569", "metadata": {}, "outputs": [ @@ -1500,7 +731,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "1fc90df0", "metadata": {}, "outputs": [], @@ -1565,7 +796,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "4d403072", "metadata": { "scrolled": false @@ -1577,10 +808,10 @@ "\n", "\n", "\n", + "Anaerobic CSTR->129151411681 -->\n", "\n", "AD\n", - "Anaerobic CSTR:c->109170427693:w\n", + "Anaerobic CSTR:c->129151411681:w\n", "\n", "\n", " Biogas\n", @@ -1588,20 +819,20 @@ "\n", "\n", "\n", + "Anaerobic CSTR->129151412281 -->\n", "\n", "AD\n", - "Anaerobic CSTR:c->109170428053:w\n", + "Anaerobic CSTR:c->129151412281:w\n", "\n", "\n", " Effluent\n", "\n", "\n", "\n", - "\n", "\n", - "109170427413:e->AD\n", + "129151411601:e->AD\n", "Anaerobic CSTR:c\n", "\n", "\n", "\n", "\n", - "\n", + "\n", "\n", - "109170427413\n", + "129151411601\n", "\n", "\n", - "\n", + "\n", "\n", - "109170427693\n", + "129151411681\n", "\n", "\n", - "\n", + "\n", "\n", - "109170428053\n", + "129151412281\n", "\n", "\n", "\n", @@ -1700,7 +931,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "b162ac79", "metadata": {}, "outputs": [], @@ -1745,7 +976,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "85b13876", "metadata": {}, "outputs": [ @@ -1848,6 +1079,14 @@ "sys # before running the simulation, 'outs' have nothing" ] }, + { + "cell_type": "markdown", + "id": "cd84e41c", + "metadata": {}, + "source": [ + "[Back to top](#top)" + ] + }, { "cell_type": "markdown", "id": "bd50264c", @@ -1858,7 +1097,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "132152fe", "metadata": {}, "outputs": [], @@ -1879,7 +1118,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "74bcbaf0", "metadata": {}, "outputs": [], @@ -1895,7 +1134,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "55247c4c", "metadata": {}, "outputs": [ @@ -2015,7 +1254,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "990d5e59", "metadata": {}, "outputs": [ @@ -2026,7 +1265,7 @@ " )" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -2047,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "6f674fab", "metadata": {}, "outputs": [ @@ -2058,7 +1297,7 @@ " )" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -2079,7 +1318,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "2ea79de8", "metadata": {}, "outputs": [ @@ -2090,7 +1329,7 @@ " )" ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, @@ -2119,7 +1358,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "d54aeb58", "metadata": {}, "outputs": [ @@ -2130,7 +1369,7 @@ " )" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -2151,7 +1390,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "e021d8fb", "metadata": { "scrolled": false @@ -2164,7 +1403,7 @@ " )" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, @@ -2193,7 +1432,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "56f3fad7", "metadata": {}, "outputs": [], @@ -2209,7 +1448,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "a879f514", "metadata": { "scrolled": false @@ -2221,7 +1460,7 @@ "Text(0, 0.5, 'Total VFA [mg/l]')" ] }, - "execution_count": 23, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, diff --git a/docs/source/tutorials/TBD_Chlorination.ipynb b/docs/source/tutorials/TBD_Chlorination.ipynb deleted file mode 100644 index 8f782219..00000000 --- a/docs/source/tutorials/TBD_Chlorination.ipynb +++ /dev/null @@ -1,1075 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "28c4658c", - "metadata": {}, - "source": [ - "# Process Design Example: Chlorination \n", - "\n", - "- **Prepared by:**\n", - " \n", - " - [Yalin Li](https://qsdsan.readthedocs.io/en/latest/authors/Yalin_Li.html)\n", - " - [Philipp Steiner](https://www.eawag.ch/en/aboutus/portrait/organisation/staff/profile/philipp-steiner/show/)\n", - " - [Eva Reynaert](https://www.eawag.ch/en/aboutus/portrait/organisation/staff/profile/eva-reynaert/show/)\n", - "\n", - "- **Covered topics:**\n", - "\n", - " - [1. Design Algorithms](#s1)\n", - " - [2. Process Algorithms](#s2)\n", - " - [3. Unit Classes](#s3)\n", - " - [4. System, TEA, and LCA](#s4)" - ] - }, - { - "cell_type": "markdown", - "id": "90d4bb2f", - "metadata": {}, - "source": [ - "---\n", - "### Note\n", - "This tutorial is stale." - ] - }, - { - "cell_type": "markdown", - "id": "903ee36f", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "8e608f02", - "metadata": {}, - "outputs": [], - "source": [ - "# Add the path to your cloned repos\n", - "import os, sys\n", - "coding_path = os.path.abspath(os.path.join(sys.path[0], '../../../../'))\n", - "for abbr in ('tmo', 'bst', 'qs'):\n", - " sys.path.append(os.path.join(coding_path, abbr))" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3dc1138e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This tutorial was made with qsdsan vNone.\n" - ] - } - ], - "source": [ - "import qsdsan as qs\n", - "print(f'This tutorial was made with qsdsan v{qs.__version__}.')" - ] - }, - { - "cell_type": "markdown", - "id": "efa4852f", - "metadata": {}, - "source": [ - "### Summary\n", - "In this example, we will show how we can set up a chlorination process in `QSDsan`, which would include a contact zone, mixing/storage tanks for the chemical sodium hypochlorite (NaOCl) and treated water, and pumps (contact zone, NaOCl dosing, water storage).\n", - "\n", - "The algorithms largely follows the methodoly presented in Jones et al., Life cycle environmental impacts of disinfection technologies used in small drinking water systems. *Environmental Science & Technology*, **2018**, *52* (5), 2998-3007. https://doi.org/10.1021/acs.est.7b04448" - ] - }, - { - "cell_type": "markdown", - "id": "b7f9ccfc", - "metadata": {}, - "source": [ - "## 1. Design Algorithms " - ] - }, - { - "cell_type": "markdown", - "id": "de048b24", - "metadata": {}, - "source": [ - "### 1.1. Contact zone" - ] - }, - { - "cell_type": "markdown", - "id": "ac3a9505", - "metadata": {}, - "source": [ - "In the contact zone, chlorine (in the form of NaOCl) is added and reacts with the influent stream to inactivate microorganims (e.g., viruses, bacteria, protoza). In this example, the contact zone is modeled as a serpentine tubing." - ] - }, - { - "cell_type": "markdown", - "id": "29d2f234", - "metadata": {}, - "source": [ - "To determine the amount of NaOCl to be added, we will need to calculate the CT (concentration$*$time) values required by the inactivation target." - ] - }, - { - "cell_type": "markdown", - "id": "e5e4fdaa", - "metadata": {}, - "source": [ - "Let's assume that we will use the following table from U.S. Environmental Protection Agency to determine the CT (in min-mg/L) for 4-log inactivation of viruses by free chlorine (Table B-2 on Page B-3 in this [Disinfection Profiling and Benchmarking Technical Guidance Manual](https://www.epa.gov/system/files/documents/2022-02/disprof_bench_3rules_final_508.pdf))." - ] - }, - { - "cell_type": "markdown", - "id": "c7f08d0a", - "metadata": {}, - "source": [ - "| Temperature (°C) | pH=6-9 | pH=10 |\n", - "| :-: | :-: | :-: |\n", - "| 0.5 | 12 | 90 |\n", - "| 5 | 8 | 60 |\n", - "| 10 | 6 | 45 |\n", - "| 15 | 4 | 30 |\n", - "| 20 | 3 | 22 |\n", - "| 25 | 2 | 15 |" - ] - }, - { - "cell_type": "markdown", - "id": "11e1d04c", - "metadata": {}, - "source": [ - "With the CT value, the desired contact time $T_{contact}$ can be calculated from the desired residual chlorine concentration $C_{res}$ (see Section 2.1): \n", - "$$\n", - "T_{contact}[min] = \\frac{CT [\\frac{mg*min}{L}]}{C_{res}[\\frac{mg}{L}]}\n", - "$$\n", - " \n", - "To get the required detention time $T_{DT}$, the desired contact time needs to be corrected by a baffling factor (BF) that accounts for potential short-circuiting:\n", - "\n", - "$$\n", - "T_{DT} [min] = \\frac{T_{contact}}{BF} \n", - "$$\n", - "\n", - "A BF value of 0.7 is typical for the serpentine tubing configuration." - ] - }, - { - "cell_type": "markdown", - "id": "c524fc12", - "metadata": {}, - "source": [ - "Dimensions of the serpentine tubing can then be calculated from the $T_{DT}$:\n", - "\n", - "$$\n", - "T_{DT} [min] = \\frac{L_p}{v} = L_p * \\frac{\\pi*{(\\frac{d_p}{2})^2}}{Q} = (AS*d_p) * \\frac{\\pi*{(\\frac{d_p}{2})^2}}{Q}\n", - "$$\n", - "\n", - "where:\n", - "- $L_p$ and $d_p$ are the length and diameter of the pipe (both in m), respectively\n", - "- AS is the aspect ratio as in $\\frac{L_p}{d_p}$, recommended to be ≧160 by the Colorado Department of Public Health and Environment as in page 16 of this [Baffling Factor Guidance Manual](https://www.colorado.gov/pacific/sites/default/files/CDPHE%20Baffling%20Factor%20Guidance%20Manual.pdf)\n", - "- Q and v are the volumetric flow rate and velocity of the influent stream, respectively" - ] - }, - { - "cell_type": "markdown", - "id": "13b2bd02", - "metadata": {}, - "source": [ - "Solve for $d_p$:\n", - "\n", - "$$\n", - "d_p [m] = (\\frac{4T_{DT}*Q}{\\pi*AS})^{1/3}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "e28c8246", - "metadata": {}, - "source": [ - "Then we can calculate the amount of material needed:\n", - "\n", - "$$\n", - "V_{PVC} [m^3] = \\pi * L_p * ((\\frac{d_p}{2}+t_{pipe})^2 - d_p^2)\n", - "$$\n", - "\n", - "where $t_{pipe}$ is the thickness of the pipe." - ] - }, - { - "cell_type": "markdown", - "id": "a903a2e1", - "metadata": {}, - "source": [ - "### 1.2. Chlorine tank" - ] - }, - { - "cell_type": "markdown", - "id": "01ed4c90", - "metadata": {}, - "source": [ - "A cylindrical tank will be used for the storage of the NaOCl solution. For a certain refill inteval $t_{refill}$, volume of the storage tank for 15 wt% NaOCl solution will be:\n", - " \n", - "$$\n", - "V_{NaOCl_{sol}}[m^3] = \\frac{M_{Cl_2}[\\frac{kg}{hr}]*t_{refill}[day]*24[\\frac{hr}{day}]*\\frac{MW_{NaOCl}}{MW_{Cl_2}}}{0.15*\\rho_{sol}[\\frac{kg}{m^3}]}\n", - "$$\n", - " \n", - "where:\n", - "- $M_{Cl_2}$ is the mass flowrate of $Cl_2$ (can be calculated from $C_{res}$, refer to Section 2.1.)\n", - "- $MW_{Cl_2}$ and $MW_{NaOCl}$ are the molar mass of $Cl_2$ (70.91 $\\frac{g}{mol}$) and NaOCl (74.44 $\\frac{g}{mol}$), respectively\n", - "- $\\rho_{sol}$ is the density of a 15% NaOCl solution (1200 $\\frac{kg}{m^3}$)" - ] - }, - { - "cell_type": "markdown", - "id": "a585fe1b", - "metadata": {}, - "source": [ - "Given that\n", - "\n", - "$$\n", - "V_{NaOCl_{sol}} = \\frac{\\pi}{4}d_{cyl}^2*h_{cyl} = \\frac{\\pi}{4}d_{cyl}^2*AS*d_{cyl} = \\frac{\\pi}{2}d_{cyl}^3\n", - "$$\n", - "\n", - "The diameter of the cylinder tank needed to hold this volume is:\n", - " \n", - "$$\n", - "d_{cyl} = \\sqrt[3]{\\frac{2*V_{NaOCl_{sol}}}{\\pi}}\n", - "$$\n", - "\n", - "The corresponding PVC volume is:\n", - "\n", - "$$\n", - "V_{wall} = \\pi*h_{cyl}*((d_{cyl}+2*t_{cyl})^2-d_{cyl}^2) = \\pi*AS*d_{cyl}*((d_{cyl}+2*t_{cyl})^2-d_{cyl}^2)\n", - "$$\n", - "\n", - "$$\n", - "V_{floor} = \\pi*(d_{cyl}+2*t_{cyl})^2*t_{cyl}\n", - "$$\n", - "\n", - "$$\n", - "V_{PVC} [m^3] = V_{wall}+V_{floor}\n", - "$$\n", - "\n", - "where:\n", - "- $h_{cyl}$, $d_{cyl}$, and $t_{cyl}$ are the height, inner diameter, and wall thickness of the cylindrical tank (all in m), respectively\n", - "- AS is the aspect ratio as in $\\frac{h_cyl}{d_cyl}$" - ] - }, - { - "cell_type": "markdown", - "id": "73664ea6", - "metadata": {}, - "source": [ - "### 1.3. Pumps" - ] - }, - { - "cell_type": "markdown", - "id": "564e9603", - "metadata": {}, - "source": [ - "For the design of the pumps, we will use the general algorithms in the `WWTpump` class in `QSDsan` (despite of the name, the pump algorithms are not limited to wastewater treatment settings)." - ] - }, - { - "cell_type": "markdown", - "id": "3954fc5f", - "metadata": {}, - "source": [ - "## 2. Process Algorithms " - ] - }, - { - "cell_type": "markdown", - "id": "fcd1a1e5", - "metadata": {}, - "source": [ - "### 2.1. Chlorine dose" - ] - }, - { - "cell_type": "markdown", - "id": "c02f398c", - "metadata": {}, - "source": [ - "Based on the following equation to take into account the amount of chlorine lost to reactions with organics (quantified as the total organic carbon, TOC and ultraviolet absorbance, UVA), we can back-calculate $C_0$ using $C_{res}$:\n", - "\n", - "$$\n", - "C_{res} = -0.8404C_0*ln\\frac{C_0}{C_{res}} - 0.404TOC [\\frac{mg_{C}}{L}]*T_{contact}*(\\frac{C_0}{UVA [1/cm]})^{-0.9108} + C_0\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "5f38c936", - "metadata": {}, - "source": [ - "\n", - " \n", - "- Q1: I'm not sure how TOC and UVA are quantified (e.g., units for them in the equation above)? \n", - "- Q2: Are there two solutions of $C_0$ at a certain $C_{res}$? If so, we probably would want to use the lower value.\n", - " - We might want to double-check the results get from ``scipy`` vs. ``flexsolve``\n", - " \n", - "" - ] - }, - { - "cell_type": "markdown", - "id": "c5a87356", - "metadata": {}, - "source": [ - "With $C_0$ solved, we will know how much NaOCl we need to add to achieve the desired CT:\n", - "\n", - "$$\n", - "M_{Cl_2}[\\frac{kg}{hr}] = Q[\\frac{m^3}{hr}]*C_0[\\frac{g}{m^3}]*\\frac{1[kg]}{1000[g]}\n", - "$$\n", - "\n", - "where:\n", - "- $M_{Cl_2}$ is the mass flowrate of $Cl_2$\n", - "- $Q$ is the volumetric flowrate of the influent" - ] - }, - { - "cell_type": "markdown", - "id": "69b8d85f", - "metadata": {}, - "source": [ - "### 2.2. Pumping energy" - ] - }, - { - "cell_type": "markdown", - "id": "87c78ea5", - "metadata": {}, - "source": [ - "Pumping energy can be calculated based on the flow rate and head pressure/loss as:\n", - "\n", - "$$\n", - "P [kW] = \\frac{mgH}{1000\\eta}\n", - "$$\n", - "\n", - "where:\n", - "- $m$ is mass flow rate in $[\\frac{kg}{s}]$\n", - "- $H$ is the head pressure/loss $[m]$\n", - "- $\\eta$ is the typical pump efficiency (set to 60%)" - ] - }, - { - "cell_type": "markdown", - "id": "a6659f39", - "metadata": {}, - "source": [ - "#### 2.2.1. For the contact zone" - ] - }, - { - "cell_type": "markdown", - "id": "6a7a1048", - "metadata": {}, - "source": [ - "In the case of serpentine tubing, head loss is the sum of the major head loss ($H_f$; due to friction) and minor head loss ($H_m$; due to bends in flow):\n", - "\n", - "$$\n", - "H [m] = H_f + H_m\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "2996a35b", - "metadata": {}, - "source": [ - "For the major head loss, the [Hazen-Williams equation](https://en.wikipedia.org/wiki/Hazen%E2%80%93Williams_equation) can be used (coefficients from [here](https://www.engineeringtoolbox.com/hazen-williams-water-d_797.html)):\n", - "\n", - "$$\n", - "H_f = \\frac{0.2083*(\\frac{100*Q}{C})^{1.852}}{100*d_p^{4.8655}} * L_p\n", - "$$\n", - "\n", - "where C is the roughness coefficient and assumed to be 150 for PVC." - ] - }, - { - "cell_type": "markdown", - "id": "7d9d7b46", - "metadata": {}, - "source": [ - "The minor head loss can be calculated as:\n", - "\n", - "$$\n", - "H_m = \\frac{\\epsilon*v^2}{2g} * N_{bend}\n", - "$$\n", - "\n", - "where:\n", - "- $\\epsilon$ is the minor loss coefficient and assumed to be 1.5\n", - "- $N_{bend}$ is the number of bends can be calculated by dividing the total length by the segment length\n", - "\n", - "$N_{bend}$ can be calculated as\n", - "\n", - "$$\n", - "N_{bend} = \\frac{L_p}{L_{seg}}\n", - "$$\n", - "\n", - "and the segment length $L_{seg}$ can be calculated based on the segment length-to-diameter ratio (recommended to be ≦40 by the Colorado Department of Public Health and Environment as in page 15 of this [Baffling Factor Guidance Manual](https://www.colorado.gov/pacific/sites/default/files/CDPHE%20Baffling%20Factor%20Guidance%20Manual.pdf))." - ] - }, - { - "cell_type": "markdown", - "id": "9f0a999c", - "metadata": {}, - "source": [ - "#### 2.2.2. For the storage tank" - ] - }, - { - "cell_type": "markdown", - "id": "aa0e0f0c", - "metadata": {}, - "source": [ - "For the cylindrical storage tank, there is no minor head loss, therefore the total head loss only comes from the friction loss. However, we need to consider head pressure needed for clorine addition, which is assumed to be 70.3 m. Therefore, the total head needed is\n", - "\n", - "$$\n", - "H = H_f + H_p = \\frac{0.2083*(\\frac{100*Q}{C})^{1.852}}{100*d_{cyl}^{4.8655}} * h_{cyl} + 70.3\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "id": "2f3ff298", - "metadata": {}, - "source": [ - "[Back to top](#top)" - ] - }, - { - "cell_type": "markdown", - "id": "b6a928f2", - "metadata": {}, - "source": [ - "## 3. Unit Classes " - ] - }, - { - "cell_type": "markdown", - "id": "d5691410", - "metadata": {}, - "source": [ - "### 3.1. Contact zone" - ] - }, - { - "cell_type": "markdown", - "id": "bbe29d99", - "metadata": {}, - "source": [ - "For the contact zone, we need to create a new class. Check out the tutorials on `SanUnit` ([basic](https://qsdsan.readthedocs.io/en/latest/tutorials/4_SanUnit_basic.html), [advanced](https://qsdsan.readthedocs.io/en/latest/tutorials/5_SanUnit_advanced.html)) for how to make a new `SanUnit` subclass." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2081965a", - "metadata": {}, - "outputs": [], - "source": [ - "from warnings import warn\n", - "from math import log, pi, ceil\n", - "from flexsolve import IQ_interpolation\n", - "from qsdsan import SanUnit, Construction\n", - "from qsdsan.sanunits import WWTpump\n", - "\n", - "class ContactZone(SanUnit):\n", - " '''\n", - " Contact zone for water disinfection using chlorine (in the form of sodium hypochlorite, NaOCl).\n", - "\n", - " Parameters\n", - " ----------\n", - " ins : Iterable(obj)\n", - " Influent stream, NaOCl (updated upon unit simulation).\n", - " outs : obj\n", - " Disinfected stream.\n", - " target_CT : float\n", - " Desired CT (concentration*time) for microorganism in min-mg/L.\n", - " C_res : float\n", - " Desired residual concentration of disinfectant in mg/L.\n", - " UVA : float\n", - " Disinfection credit from UVA.\n", - " PVC_thickness : float\n", - " Thickness of the PVC material in m.\n", - "\n", - " References\n", - " ----------\n", - " [1] Jones et al., Life cycle environmental impacts of disinfection technologies\n", - " used in small drinking water systems.\n", - " Environmental Science & Technology, 2018, 52 (5), 2998-3007.\n", - " https://doi.org/10.1021/acs.est.7b04448\n", - " [2] Disinfection Profiling and Benchmarking Technical Guidance Manual.\n", - " U.S. Environmental Protection Agency.\n", - " https://www.epa.gov/system/files/documents/2022-02/disprof_bench_3rules_final_508.pdf\n", - " [3] Baffling Factor Guidance Manual.\n", - " Colorado Department of Public Health and Environment.\n", - " https://www.colorado.gov/pacific/sites/default/files/CDPHE%20Baffling%20Factor%20Guidance%20Manual.pdf\n", - "\n", - " Examples\n", - " --------\n", - " Here we will skip this as we will show how to use it later.\n", - " '''\n", - "\n", - " _N_ins = 2 # influent stream, NaOCl solution\n", - " _N_outs = 1 # disinfected water\n", - " baffling_factor = 0.7\n", - " aspect_ratio = 160 # length over diamteter\n", - " segment_L_to_dia = 40 # segment length to diameter ratio\n", - " C = 150 # roughness coefficient\n", - " epsilon = 1.5 # minor loss coefficient\n", - " pump_eff = 0.6\n", - "\n", - " def __init__(self, ID='', ins=None, outs=(), thermo=None, init_with='WasteStream',\n", - " target_CT=4, # based on the table, set default at T=15°C and pH=6-9\n", - " C_res=10, UVA=1, #!!! need to update\n", - " PVC_thickness=0.005,\n", - " **kwargs):\n", - " SanUnit.__init__(self, ID, ins, outs, thermo, init_with)\n", - " self.target_CT = target_CT\n", - " self.C_res= C_res\n", - " self.UVA = UVA\n", - " self.PVC_thickness = PVC_thickness\n", - " for attr, val in kwargs: setattr(self, kwargs)\n", - "\n", - " # To consider LCA impacts from the construction material\n", - " self.construction = (\n", - " Construction('ContactZone_PVC', linked_unit=self,\n", - " item='PVC', quantity_unit='kg'),\n", - " Construction('ContactZone_SS', linked_unit=self,\n", - " item='StainlessSteel', quantity_unit='kg'),\n", - " )\n", - "\n", - " # Pump\n", - " ID = self.ID\n", - " eff = self.outs[0]\n", - " self.pump = WWTpump(\n", - " ID=ID+'_pump', ins=eff.proxy(eff.ID+'_proxy'),\n", - " pump_type='', # use the generic pump algorithm\n", - " N_pump=1, capacity_factor=1, include_pump_cost=True,\n", - " include_building_cost=False, include_OM_cost=False,\n", - " )\n", - "\n", - " # Target function to solve C_0 -->\n", - " #i first thought the found result was not matching another solver,\n", - " # however the equation just has 2 solutions.\n", - " # We'll probably have to discuss with Eva, which solution to use.\n", - " @staticmethod\n", - " def _C_res_at_C_0(C_0, TOC, contact_time, UVA, C_res):\n", - " C_res2 = -0.8404*C_0*log(C_0/C_res) - 0.404*TOC*contact_time*(C_0/UVA)**(-0.9108) + C_0\n", - " return C_res2-C_res\n", - "\n", - " # Implement process algorithms\n", - " def _run(self):\n", - " inf, naocl = self.ins\n", - " eff, = self.outs\n", - "\n", - " # Calculate contact time and C_0\n", - " TOC = inf.TOC # in mg/L\n", - " UVA = self.UVA\n", - " C_res = self.C_res\n", - " contact_time = self.target_CT / self.C_res\n", - " try:\n", - " C_0 = IQ_interpolation( # in mg/L\n", - " f=self._C_res_at_C_0, x0=C_res, x1=100*C_res, # assume that C_0 won't be >100X of C_res\n", - " ytol=1e-6, args=(TOC, contact_time, UVA, C_res),\n", - " checkbounds=False)\n", - " except:\n", - " warn('Could not find C_0 for the specified values of TOC, contact_time, UVA and C_res.'\n", - " 'C_0 is assumed to be the same as C_res, resullts may be faulty!')\n", - " C_0 = C_res # assumed\n", - "\n", - " C_naocl = C_0/70.91*74.44 # 1-to-1 molar conversion of C_0 (for Cl2) to NaOCl\n", - " naocl.imass['NaOCl'] = m_naocl = inf.F_vol * C_naocl / 1000 # m3*mg/L/1000 = kg\n", - " naocl.imass['Water'] = m_naocl/0.15 - m_naocl\n", - "\n", - " eff.mix_from(self.ins)\n", - " eff.imass['NaOCl'] *= C_res/C_0 # account for the consumed NaOCl\n", - "\n", - " _units = { # units of measure for the design parameters\n", - " 'Pipe diameter': 'm',\n", - " 'Pipe length': 'm',\n", - " 'Total PVC': 'm3',\n", - " 'Pump head': 'm',\n", - " 'Pump stainless steel': 'kg',\n", - " }\n", - "\n", - " # Implement design algorithms\n", - " def _design(self):\n", - " D = self.design_results\n", - "\n", - " # Pipe dimensions\n", - " contact_time=self.target_CT / self.C_res\n", - " t_DT = contact_time / self.baffling_factor # theoretical detention time\n", - " Q = self.F_vol_in # m3/hr\n", - " t_PVC, AS, C = self.PVC_thickness, self.aspect_ratio, self.C\n", - " dia = (4*t_DT*Q/(pi*AS))**(1/3)\n", - " dia_out = dia + 2*t_PVC\n", - " D['Pipe diameter'] = dia\n", - " L_p = D['Pipe length'] = dia * AS\n", - " V_PVC = D['Total PVC'] = pi * L_p * ((dia_out/2)**2-dia**2)\n", - "\n", - " # Pump head\n", - " H_f = 0.2083*(100*Q/C)**1.852/(100*dia**4.8655)*L_p # m\n", - " v = Q/(pi*dia**2)\n", - " N_bend = ceil(L_p/(dia*self.segment_L_to_dia))\n", - " H_m = self.epsilon*v**2/(2*9.81)*N_bend\n", - " H = D['Pump head'] = H_f + H_m\n", - "\n", - " # Pump\n", - " pump = self.pump\n", - " pump.simulate()\n", - " m_ss = D['Pump stainless steel'] = pump.design_results['Pump stainless steel']\n", - " self.power_utility.rate = self.F_mass_in*9.81*H/(1000*self.pump_eff)\n", - "\n", - " #!!! Will need CAPEX/OPEX/impacts of the UVA lights as well\n", - "\n", - " # Construction materials for TEA/LCA\n", - " self.construction[0].quantity = V_PVC\n", - " self.construction[1].quantity = m_ss\n", - " self.add_construction(add_cost=True) # this will add PVC and SS cost\n", - "\n", - " _F_BM_default = {\n", - " 'PVC': 1,\n", - " 'StainlessSteel': 1,\n", - " 'Pump': 1.18*(1+0.007/100),\n", - " }\n", - " def _cost(self):\n", - " C = self.baseline_purchase_costs\n", - " C['Pump'] = self.pump.baseline_purchase_costs['Pump']" - ] - }, - { - "cell_type": "markdown", - "id": "d336dead", - "metadata": {}, - "source": [ - "### 3.2. ChlorineTank" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1af670fd", - "metadata": {}, - "outputs": [], - "source": [ - "from qsdsan.sanunits import MixTank\n", - "\n", - "class ChlorineTank(MixTank):\n", - " '''\n", - " A subclass of `MixTank` with an auxiliary pump for chlorine storage.\n", - "\n", - " Parameters\n", - " ----------\n", - " ins : Iterable(obj)\n", - " NaOCl, water.\n", - " outs : obj\n", - " NaOCl solution.\n", - " t_refill : float\n", - " Tank refill interval in d.\n", - " head_pressure : float\n", - " Assumed head pressure for the pump in m.\n", - " PVC_thickness : float\n", - " Thickness of the PVC material in m.\n", - "\n", - " See Also\n", - " --------\n", - " `qsdsan.sanunits.MixTank `_\n", - " '''\n", - "\n", - " aspect_ratio = 2 # height over diameter\n", - " C = 150 # roughness coefficient\n", - " pump_eff = 0.6\n", - "\n", - " def __init__(self, ID='', ins=None, outs=(), thermo=None, init_with='WasteStream',\n", - " t_refill=7, head_pressure=70.3, PVC_thickness=0.02, **kwargs):\n", - " MixTank.__init__(self, ID, ins, outs, thermo)\n", - " self.head_pressure = head_pressure\n", - " self.PVC_thickness = PVC_thickness\n", - " for attr, val in kwargs: setattr(self, kwargs)\n", - "\n", - " # To consider LCA impacts from the construction material\n", - " self.construction = (\n", - " Construction('ChlorineTank_PVC', linked_unit=self,\n", - " item='PVC', quantity_unit='kg'),\n", - " Construction('ChlorineTank_SS', linked_unit=self,\n", - " item='StainlessSteel', quantity_unit='kg'),\n", - " )\n", - " eff = self.outs[0]\n", - " self.pump = WWTpump(\n", - " ID=self.ID+'_pump', ins=eff.proxy(eff.ID+'_proxy'),\n", - " pump_type='', # use the generic pump algorithm\n", - " N_pump=1, capacity_factor=1, include_pump_cost=True,\n", - " include_building_cost=False, include_OM_cost=False,\n", - " )\n", - "\n", - " def _run(self):\n", - " naocl, water = self.ins # NaOCl dose will be adjusted when assesmbling the system\n", - " eff = self.outs[0]\n", - " naocl.copy_flow(eff, IDs=('NaOCl',))\n", - " water.copy_flow(eff, IDs=('Water',))\n", - "\n", - "\n", - " _units = { # units of measure for the design parameters\n", - " 'Tank diameter': 'm',\n", - " 'Tank height': 'm',\n", - " 'Total PVC': 'm3',\n", - " 'Pump head': 'm',\n", - " 'Pump stainless steel': 'kg',\n", - " }\n", - " def _design(self):\n", - " MixTank._design(self)\n", - " D = self.design_results\n", - " eff = self.outs[0]\n", - "\n", - " # Cylindrical tank\n", - " V_naocl = self.ins[0].F_vol #!!! the simulated density is ~1.1 g/mL, want to use 1.2?\n", - " AS, t_PVC = self.aspect_ratio, self.PVC_thickness\n", - " dia = 2*((V_naocl/(pi*AS))**(1/3))\n", - " dia_out = dia + 2*self.PVC_thickness\n", - "\n", - " D['Tank diameter'] = dia\n", - " h_cyl = D['Tank height'] = dia * AS\n", - " V_wall = pi*h_cyl*(dia_out**2-dia**2)\n", - " V_floor = pi * dia_out**2 * t_PVC\n", - " V_PVC = D['Total PVC'] = V_wall + V_floor\n", - "\n", - " # Pump\n", - " Q = eff.F_vol\n", - " C = self.C\n", - " pump = self.pump\n", - " H_f = 0.2083*(100*Q/C)**1.852/(100*dia**4.8655) * h_cyl # m\n", - " H_p = self.head_pressure\n", - " D['Pump head'] = H_f + H_p\n", - " pump.simulate()\n", - " m_ss = D['Pump stainless steel'] = pump.design_results['Pump stainless steel']\n", - "\n", - " # # This is if want to use the default algorithms for calculating electricity usage,\n", - " # # it's more conservative (i.e., the efficiency is lower)\n", - " # pump._H_f = H_f * 3.28 # ft\n", - " # pump._H_p = H_p * 3.28 # ft\n", - "\n", - " # Construction materials for TEA/LCA\n", - " self.construction[0].quantity = V_PVC\n", - " self.construction[1].quantity = m_ss\n", - " self.add_construction(add_cost=True) # this will add PVC and SS cost\n", - "\n", - " _F_BM_default = {\n", - " 'PVC': 1,\n", - " 'StainlessSteel': 1,\n", - " 'Pump': 1.18*(1+0.007/100),\n", - " }\n", - " def _cost(self):\n", - " MixTank._cost(self) #!!! this will also add the cost for a stainless steel tank\n", - " pump = self.pump\n", - " self.baseline_purchase_costs['Pump'] = pump.baseline_purchase_costs['Pump']\n", - " H = self.design_results['Pump head']\n", - " self.power_utility.rate += self.F_mass_in*9.81*H/(1000*self.pump_eff)" - ] - }, - { - "cell_type": "markdown", - "id": "476ac60d", - "metadata": {}, - "source": [ - "\n", - " \n", - "- Q3: Density of the simulated NaOCl solution is ~1.1 g/mL instead of 1.2, which will make the design more conservative (since volume is larger), do we want to stick to the 1.2?\n", - " - Related, when calculating tank volume, we typically considers a \"working volume\" factor (<1, our default is 0.8) since we don't want to fill the tank 100% full. So the actual volume will be $\\frac{V_{calculated}}{factor}$, do we want to do the same for this storage tank?\n", - " \n", - "" - ] - }, - { - "cell_type": "markdown", - "id": "62d9849e", - "metadata": {}, - "source": [ - "## 4. System, TEA, and LCA " - ] - }, - { - "cell_type": "markdown", - "id": "650a5f5c", - "metadata": {}, - "source": [ - "Finally it's time to create and simulate the entire system." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "68423ea8", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/yalinli_cabbi/Library/CloudStorage/OneDrive-Personal/Coding/bst/biosteam/_unit.py:635: RuntimeWarning: the purchase cost item, 'Tanks', has no defined bare-module factor in the 'ChlorineTank.F_BM' dictionary; bare-module factor now has a default value of 1\n", - " warn(warning)\n" - ] - } - ], - "source": [ - "# Identify the components needed for simulation\n", - "import qsdsan as qs\n", - "from qsdsan import Component, Components, set_thermo, WasteStream, \\\n", - " System, SimpleTEA, ImpactIndicator, ImpactItem, StreamImpactItem, LCA\n", - "\n", - "# Set up components to be used in simulation\n", - "kwargs = {\n", - " 'phase': 'l',\n", - " 'particle_size': 'Soluble',\n", - " 'degradability': 'Undegradable',\n", - " 'organic': False,\n", - "}\n", - "H2O = Component('H2O', **kwargs)\n", - "\n", - "kwargs['phase'] = 's'\n", - "kwargs['particle_size'] = 'Particulate'\n", - "NaOCl = Component('NaOCl', **kwargs)\n", - "NaOCl.copy_models_from(qs.Component('HOCl', **kwargs), ['V']) # this gives a rho of ~1.1 g/mL for 15 wt% solution\n", - "\n", - "cmps = Components([H2O, NaOCl])\n", - "cmps.compile()\n", - "cmps.set_alias('H2O', 'Water')\n", - "set_thermo(cmps)\n", - "\n", - "# # Redundant codes, remove after module done\n", - "# HCl = Component('HCl', **kwargs)\n", - "# HOCl = Component('HOCl', **kwargs)\n", - "# NH3 = Component('NH3', **kwargs) # assumed to be liquefied NH3\n", - "# cmps = Components([H2O, NaOCl, HCl, HOCl, NH3])\n", - "# cmps.set_alias('NH3', 'Ammonia')\n", - "# s = WasteStream(Water=85, NaOCl=15, units='kg/hr')\n", - "\n", - "\n", - "# Impact items for LCA, values all made-up now\n", - "GWP = ImpactIndicator('GWP', unit='kg CO2')\n", - "PVC = ImpactItem('PVC', GWP=1, price=1)\n", - "StainlessSteel = ImpactItem('StainlessSteel', GWP=5, price=5)\n", - "NaOCl_item = StreamImpactItem('naocl_item', GWP=2)\n", - "e_item = ImpactItem('e_item', functional_unit='kWh', GWP=1.1)\n", - "\n", - "# Streams\n", - "influent = WasteStream('influent', Water=100, units='kg/hr') # an assumed fake stream\n", - "naocl = WasteStream('naocl', price=1, stream_impact_item=NaOCl_item, units='kg/hr') # price is made-up\n", - "water = WasteStream('water')\n", - "disinfected = WasteStream('disinfected')\n", - "\n", - "U1 = ContactZone('U1', ins=(influent, 'naocl_solution'), outs=disinfected)\n", - "U2 = ChlorineTank('U2', ins=(naocl, water), outs=1-U1)\n", - "\n", - "sys = System('sys', path=(U1, U2))\n", - "sys.simulate()\n", - "\n", - "tea = SimpleTEA(sys, discount_rate=0.5, income_tax=0.3, lifetime=10)\n", - "\n", - "get_e_item_quantity = lambda: (sys.get_electricity_consumption()-sys.get_electricity_production())*tea.lifetime\n", - "lca = LCA(sys, lifetime=tea.lifetime, e_item=get_e_item_quantity)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2fd30f57", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "450.8329582699148" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# TEA results\n", - "def get_price():\n", - " price = tea.solve_price(disinfected)\n", - " price = price*disinfected.F_mass/disinfected.F_vol # per m3\n", - " return price\n", - "\n", - "get_price()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "72440dfe", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "37102.10326916433" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# LCA results\n", - "def get_impact():\n", - " impact = lca.get_total_impacts(time=1)['GWP'] # per hour\n", - " impact = impact/disinfected.F_vol # per m3\n", - " return impact\n", - "\n", - "get_impact()" - ] - }, - { - "cell_type": "markdown", - "id": "8bdf18d1", - "metadata": {}, - "source": [ - "\n", - " \n", - "We need the following data for TEA/LCA (below are ones I can think of now, there might be more)\n", - "- Lifetime of the equipment and TEA/LCA\n", - "- TEA\n", - " - Costs of the unit. If we don't have the cost for the entire unit, we can calculate based on the materials (and we would need the unit costs of PVC/stainless steel), as well as the UVA lights\n", - " - Costs of NaOCl (pure vs. solution?)\n", - " - Electricity usage of UVA lights\n", - " - Other assumptions like discount rate, income tax, etc.\n", - "- LCA\n", - " - Life cycle inventory assessment method (e.g., ReCiPe) with the corresponding characterization factors for materials (PVC, stainless steel, UVA lights), chemicals (NaOCl), and electricity. I only used GWP here as an example, we can do any number of LCIA methods/indicators you like.\n", - " \n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "33c60ab6", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a83ecc29", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "df2274a3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "257b7c8a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a592d8a3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7e7599b4", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "275115c2", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "id": "9d9a485a", - "metadata": {}, - "source": [ - "[Back to top](#top)" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "5c4384bbfe0fafd87c455cafafefa588d87617773c75dc9eb96f43c39a856362" - }, - "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.9.13" - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}