diff --git a/docs/_examples/index.rst b/docs/_examples/index.rst index a7390d5751..fd1b685862 100644 --- a/docs/_examples/index.rst +++ b/docs/_examples/index.rst @@ -11,6 +11,7 @@ The examples are categorized into the following categories: .. toctree:: :maxdepth: 2 + ../examples/getting_started tutorials applications reference diff --git a/docs/basic_usage.rst b/docs/basic_usage.rst deleted file mode 100644 index 04108fc598..0000000000 --- a/docs/basic_usage.rst +++ /dev/null @@ -1,96 +0,0 @@ -.. _basic_usage: - -########### -Basic Usage -########### - -It is relatively easy to get going with a quick simulation in OpenPNM. -In fact the following code block produces a mercury intrusion simulation in -just a few lines. - -Problem setup -------------- - -.. code-block:: python - - import openpnm as op - - # Define geometrical parameters - Lc = 1e-4 - Nx, Ny, Nz = (10, 10, 10) - - # Generate network, geometry, phase, and physics - pn = op.network.Cubic(shape=[Nx, Ny, Nz], spacing=Lc) - geo = op.geometry.SpheresAndCylinders(network=pn, pores=pn.Ps, throats=pn.Ts) - Hg = op.phases.Mercury(network=pn) - phys = op.physics.Standard(network=pn, phase=Hg, geometry=geo) - - # Create algorithm and run simulation - mip = op.algorithms.Porosimetry(network=pn, phase=Hg) - mip.set_inlets(pores=pn.pores(['left', 'right', 'top', 'bottom'])) - mip.run() - -Basic visualization -------------------- - -The results can be visualized with ``mip.plot_intrusion_curve()`` giving -something like this: - -.. image:: https://user-images.githubusercontent.com/14086031/77930201-96363b80-7278-11ea-95fd-4a55fb1d6148.png - :width: 800px - -Calculating permeability ------------------------- - -As another example, the permeability coefficient can be found as follows: - -.. code-block:: python - - # Generate phase and physics - water = op.phases.Water(network=pn) - phys = op.physics.Standard(network=pn, phase=water, geometry=geo) - - # Create algorithm, set boundary conditions and run simulation - sf = op.algorithms.StokesFlow(network=pn, phase=water) - Pin, Pout = (200_000, 101_325) - sf.set_value_BC(pores=pn.pores('left'), values=Pin) - sf.set_value_BC(pores=pn.pores('right'), values=Pout) - sf.run() - -The total flow rate into the domain through the boundary pores can be found -using ``sf.rate(pores=pn.pores('left'))``. The permeability coefficient -can be found by inserting known values into Darcy's law as follows: - -.. code-block:: python - - Q = sf.rate(pores=pn.pores('left')) - A = Ny*Nz*Lc**2 - L = Nx*Lc - mu = water['pore.viscosity'].mean() - K = Q*mu*L/(A*(Pin-Pout)) - -Adjusting pore size distribution --------------------------------- - -It's also worth explaining how to adjust the pore size distribution of the -network, so that the capillary curve and permeability coefficient can be -changed to match known values. The ``geo`` object controls the geometric -properties, and it possess models to calculate values on demand. Let's -change the pore size distribution to a Weibull distribution, but first -let's store the existing values in a dummy variable so we can compare -later. - -.. code-block:: python - - import op.models.geometry as gmods - - geo['pore.old_diameter'] = geo.pop('pore.diameter') - geo.add_model(propname='pore.diameter', - model=gmods.pore_size.weibull, - shape=0.5, loc=0, scale=1e-5) - - -Now you can run ``geo.show_hist(['pore.old_diameter', 'pore.diameter'])`` -to get a quick glance at the histograms of the two distributions. - -More complex tasks are explained in the :doc:`examples <../_examples/index>` page. diff --git a/docs/index.rst b/docs/index.rst index 13255479c9..2db1f1ea5f 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -25,7 +25,6 @@ simulations. :maxdepth: 0 installation - basic_usage modules/index _examples/index diff --git a/docs/modules/index.rst b/docs/modules/index.rst index d05ea42a9b..11a34505c3 100644 --- a/docs/modules/index.rst +++ b/docs/modules/index.rst @@ -20,4 +20,3 @@ Module Reference openpnm.algorithms openpnm.topotools openpnm.io - openpnm.metrics diff --git a/examples/basic_usage.ipynb b/examples/basic_usage.ipynb new file mode 100644 index 0000000000..e5b942d7cc --- /dev/null +++ b/examples/basic_usage.ipynb @@ -0,0 +1,328 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4d724eae", + "metadata": {}, + "source": [ + "# Basic Usage\n", + "\n", + "It is relatively easy to get going with a quick simulation in OpenPNM.\n", + "In fact the following code block produces a mercury intrusion simulation in\n", + "just a few lines." + ] + }, + { + "cell_type": "markdown", + "id": "d122c429", + "metadata": {}, + "source": [ + "## Problem setup" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "1cc50017", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "══════════════════════════════════════════════════════════════════════════════\n", + "net : \n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " # Properties Valid Values\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " 2 pore.coords 1000 / 1000\n", + " 3 throat.conns 2700 / 2700\n", + " 4 pore.coordination_number 1000 / 1000\n", + " 5 pore.max_size 1000 / 1000\n", + " 6 throat.spacing 2700 / 2700\n", + " 7 pore.seed 1000 / 1000\n", + " 8 pore.diameter 1000 / 1000\n", + " 9 throat.max_size 2700 / 2700\n", + " 10 throat.diameter 2700 / 2700\n", + " 11 throat.cross_sectional_area 2700 / 2700\n", + " 12 throat.hydraulic_size_factors 2700 / 2700\n", + " 13 throat.diffusive_size_factors 2700 / 2700\n", + " 14 throat.lens_volume 2700 / 2700\n", + " 15 throat.length 2700 / 2700\n", + " 16 throat.total_volume 2700 / 2700\n", + " 17 throat.volume 2700 / 2700\n", + " 18 pore.volume 1000 / 1000\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " # Labels Assigned Locations\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " 2 pore.surface 488\n", + " 3 throat.surface 972\n", + " 4 pore.left 100\n", + " 5 pore.right 100\n", + " 6 pore.front 100\n", + " 7 pore.back 100\n", + " 8 pore.bottom 100\n", + " 9 pore.top 100\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n" + ] + } + ], + "source": [ + "import openpnm as op\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "pn = op.network.Cubic([10, 10, 10], spacing=1e-4)\n", + "pn.add_model_collection(op.models.collections.geometry.spheres_and_cylinders)\n", + "pn.regenerate_models()\n", + "print(pn)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "39c7e190-2caf-4fa8-ba76-d56fae4d07b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "══════════════════════════════════════════════════════════════════════════════\n", + "phase_01 : \n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " # Properties Valid Values\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " 2 pore.temperature 1000 / 1000\n", + " 3 pore.pressure 1000 / 1000\n", + " 4 throat.contact_angle 2700 / 2700\n", + " 5 pore.thermal_conductivity 1000 / 1000\n", + " 6 pore.surface_tension 1000 / 1000\n", + " 7 pore.viscosity 1000 / 1000\n", + " 8 pore.density 1000 / 1000\n", + " 9 pore.molar_density 1000 / 1000\n", + " 10 throat.entry_pressure 2700 / 2700\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " # Labels Assigned Locations\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n", + " 2 pore.all 1000\n", + " 3 throat.all 2700\n", + "――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――\n" + ] + } + ], + "source": [ + "hg = op.phase.Mercury(network=pn)\n", + "hg.add_model(propname='throat.entry_pressure',\n", + " model=op.models.physics.capillary_pressure.washburn)\n", + "hg.regenerate_models()\n", + "print(hg)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "cb0f3ee8-2d91-4a28-9bda-6e1abf363da9", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "add986a48b8341958fef54b02bca41dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Performing drainage simulation: 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = mip.pc_curve()\n", + "fig, ax = plt.subplots()\n", + "ax.semilogx(data.pc, data.snwp, 'k-o')\n", + "ax.set_xlabel('Capillary Pressure [Pa]')\n", + "ax.set_ylabel('Mercury Saturation');" + ] + }, + { + "cell_type": "markdown", + "id": "7f5c50c1", + "metadata": {}, + "source": [ + "## Calculating permeability\n", + "\n", + "As another example, the permeability coefficient can be found as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "aca961f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate phase and physics\n", + "water = op.phase.Water(network=pn)\n", + "water.add_model(propname='throat.hydraulic_conductance',\n", + " model=op.models.physics.hydraulic_conductance.generic_hydraulic)\n", + "\n", + "# Create algorithm, set boundary conditions and run simulation\n", + "sf = op.algorithms.StokesFlow(network=pn, phase=water)\n", + "Pin, Pout = (200_000, 101_325)\n", + "sf.set_value_BC(pores=pn.pores('left'), values=Pin)\n", + "sf.set_value_BC(pores=pn.pores('right'), values=Pout)\n", + "sf.run()" + ] + }, + { + "cell_type": "markdown", + "id": "010bcf56", + "metadata": {}, + "source": [ + "The total flow rate into the domain through the boundary pores can be found\n", + "using ``sf.rate(pores=pn.pores('xmin'))``. The permeability coefficient\n", + "can be found by inserting known values into Darcy's law as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "a9e72cc5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[6.92417039e-13]\n" + ] + } + ], + "source": [ + "Q = sf.rate(pores=pn.pores('left'))\n", + "A = Ny*Nz*Lc**2\n", + "L = Nx*Lc\n", + "mu = water['pore.viscosity'].mean()\n", + "K = Q*mu*L/(A*(Pin-Pout))\n", + "print(K)" + ] + }, + { + "cell_type": "markdown", + "id": "a4cdab94", + "metadata": {}, + "source": [ + "## Adjusting pore size distribution\n", + "\n", + "It's also worth explaining how to adjust the pore size distribution of the network, so that the capillary curve and permeability coefficient can be changed to match known values. The ``geo`` object controls the geometric properties, and it possess models to calculate values on demand. Let's change the pore size distribution to a Weibull distribution, but first let's store the existing values in a dummy variable so we can compare later." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "ab23c414", + "metadata": {}, + "outputs": [], + "source": [ + "import openpnm.models.geometry as gmods\n", + "\n", + "pn['pore.old_diameter'] = pn.pop('pore.diameter')\n", + "pn.add_model(propname='pore.diameter',\n", + " model=gmods.pore_size.weibull,\n", + " shape=0.5, loc=0, scale=1e-5)" + ] + }, + { + "cell_type": "markdown", + "id": "252bdeb6", + "metadata": {}, + "source": [ + "Now you can use `matplotlib.` to get a quick glance at the histograms of the two distributions." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "1aae9dfd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.hist(pn['pore.diameter'], edgecolor='k', label='new diameter')\n", + "ax.hist(pn['pore.old_diameter'], edgecolor='k', label='old_diameter')\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "0251bc1d", + "metadata": {}, + "source": [ + "More complex tasks are explained in the [examples](../_examples/index) page." + ] + } + ], + "metadata": { + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements/docs.txt b/requirements/docs.txt index 6f7bc2d619..913eda84c6 100644 --- a/requirements/docs.txt +++ b/requirements/docs.txt @@ -4,7 +4,7 @@ myst-nb numpydoc pandoc plotly -pydata-sphinx-theme=0.9 +pydata-sphinx-theme sphinx sphinx-copybutton sphinx-design