├── .github └── workflows │ ├── ci.yml │ └── notebook-test.yml ├── .gitignore ├── LICENSE ├── MANIFEST.in ├── README.md ├── docs ├── Makefile ├── changelogs.md ├── conf.py ├── dms.rst ├── index.rst ├── make.bat ├── solvers.rst └── utils.rst ├── environment.yml ├── examples ├── amb+.ipynb ├── amh_b+.ipynb ├── banner.jpeg ├── diffusionEquation.ipynb ├── fourierMethod.ipynb ├── gray-scott.ipynb ├── modelB.ipynb └── modelB_ST.ipynb ├── makefile ├── pygl ├── __init__.py ├── dms.pyx ├── modelB_correlations.ipynb ├── models.py ├── solvers.pyx ├── tests │ ├── installTests.py │ └── testNotebooks.py └── utils.pyx ├── requirements.txt ├── setup.py └── tests ├── installTests.py └── testNotebooks.py /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | 4 | on: push 5 | 6 | 7 | jobs: 8 | 9 | build-and-test: 10 | name: Install and test 11 | runs-on: ubuntu-latest 12 | 13 | steps: 14 | - uses: actions/checkout@v4 15 | - name: Set up Python 16 | uses: actions/setup-python@v5 17 | - name: Print version 18 | run: python -c "import sys; print(sys.version)" 19 | 20 | - name: Install dependencies 21 | run: python -m pip install -r requirements.txt 22 | 23 | - name: Install pygl 24 | run: python setup.py install --user || exit 1 25 | 26 | -------------------------------------------------------------------------------- /.github/workflows/notebook-test.yml: -------------------------------------------------------------------------------- 1 | name: Notebooks 2 | 3 | on: push 4 | 5 | jobs: 6 | 7 | build-and-test: 8 | name: notebooks 9 | runs-on: ubuntu-latest 10 | 11 | steps: 12 | - uses: actions/checkout@v4 13 | - name: Set up Python 14 | uses: actions/setup-python@v5 15 | - name: Print version 16 | run: python -c "import sys; print(sys.version)" 17 | 18 | - name: Install dependencies 19 | run: python -m pip install -r requirements.txt 20 | 21 | - name: Install pygl 22 | run: python setup.py install --user || exit 1 23 | - name: testing-notebooks 24 | shell: bash -l {0} 25 | run: | 26 | cd tests && python testNotebooks.py 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | dist 2 | *egg* 3 | *.pyc 4 | *.so 5 | *.ipynb_checkpoints 6 | *~ 7 | *.swp 8 | *.mat 9 | *.swo 10 | *.html 11 | *.c 12 | 13 | dms.c 14 | dms.html 15 | utils.c 16 | utils.html 17 | solvers.html 18 | solvers.html 19 | 20 | *.aux 21 | *.lof 22 | *.log 23 | *.lot 24 | *.fls 25 | *.out 26 | *.toc 27 | 28 | *.dvi 29 | *.bbl 30 | *.bcf 31 | *.blg 32 | *-blx.aux 33 | *-blx.bib 34 | *.run.xml 35 | build/ 36 | 37 | ## Build tool auxiliary files: 38 | *.fdb_latexmk 39 | *.synctex.gz 40 | *.synctex.gz(busy) 41 | *.pdfsync 42 | 43 | *.alg 44 | *.loa 45 | 46 | # amsthm 47 | *.thm 48 | 49 | # beamer 50 | *.nav 51 | *.snm 52 | *.vrb 53 | 54 | 55 | # hyperref 56 | *.brf 57 | 58 | 59 | # makeidx 60 | *.idx 61 | *.ilg 62 | *.ind 63 | *.ist 64 | 65 | # minitoc 66 | *.maf 67 | *.mtc 68 | *.mtc0 69 | 70 | *.pyg 71 | 72 | 73 | # sagetex 74 | *.sagetex.sage 75 | *.sagetex.py 76 | *.sagetex.scmd 77 | 78 | 79 | *.tdo 80 | *.vtk 81 | *.vtu 82 | *.pvsm 83 | *.npz 84 | *.pvd 85 | build/ 86 | .DS_Store 87 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 University of Cambridge 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /MANIFEST.in: -------------------------------------------------------------------------------- 1 | include pygl/*pyx 2 | include pygl/*pxd 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![Self-propulsion of active droplets](https://raw.githubusercontent.com/rajeshrinet/pygl/master/examples/banner.jpeg) 2 | ## PyGL: statistical field theory in Python [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/rajeshrinet/pygl/master?filepath=examples) ![CI](https://github.com/rajeshrinet/pygl/workflows/CI/badge.svg) ![Notebooks](https://github.com/rajeshrinet/pygl/workflows/Notebooks/badge.svg) [![Documentation Status](https://readthedocs.org/projects/pygl/badge/?version=latest)](https://pygl.readthedocs.io/en/latest/?badge=latest)[![PyPI version](https://badge.fury.io/py/pygl.svg)](https://badge.fury.io/py/pygl) [![Downloads](https://pepy.tech/badge/pygl)](https://pepy.tech/project/pygl) 3 | 4 | [About](#about) | [Documentation](https://pygl.readthedocs.io/en/latest/) | [News](#news) | [Installation](#installation) | [Examples](#examples) | [Publications ](#publications)| [Support](#support) | [License](#license) 5 | 6 | 7 | ## About 8 | [PyGL](https://github.com/rajeshrinet/pygl) is a numerical library for statistical field theory in Python. The name GL corresponds to the [Ginzburg–Landau theory](https://en.wikipedia.org/wiki/Ginzburg%E2%80%93Landau_theory). The library has been specifically designed to study field theories without time-reversal symmetry. The library can be used to study models of statistical physics of various symmetries and conservation laws. In particular, we allow models with mass and momentum conservations. The library constructs differentiation matrices using finite-difference and spectral methods. To study the role of momentum conservation, the library also allows computing fluid flow from the solution of the Stokes equation. 9 | 10 | ![Self-propulsion of active droplets](https://raw.githubusercontent.com/rajeshrinet/pystokes-misc/master/gallery/droplets/ssi.gif) 11 | 12 | The above simulation is done using PyGL. It shows steady-state microphase separation (phase separation arrested to a length-scale) in an active scalar field theory. A self-shearing instability interrupts the growth of droplets by splitting them. Read more: https://arxiv.org/abs/1907.04819 13 | 14 | 15 | 16 | ## Installation 17 | 18 | ### From a checkout of this repository 19 | 20 | Install PyGL and required dependencies using 21 | 22 | ``` 23 | >> git clone https://github.com/rajeshrinet/pygl.git 24 | >> cd pygl 25 | >> pip install -r requirements.txt 26 | >> python setup.py install 27 | ``` 28 | 29 | Install PyGL and its dependencies in a `pygl` environment: 30 | 31 | ``` 32 | >> git clone https://github.com/rajeshrinet/pygl.git 33 | >> cd pygl 34 | >> make env 35 | >> conda activate pygl 36 | >> make 37 | ``` 38 | 39 | ### Pip 40 | Alternatively, install the latest PyPI version 41 | 42 | ``` 43 | >> pip install pygl 44 | ``` 45 | 46 | 47 | ## Examples 48 | 49 | See the [examples folder](https://github.com/rajeshrinet/pygl/tree/master/examples) for a list of examples. 50 | 51 | ## Publications 52 | * [Hydrodynamically interrupted droplet growth in scalar active matter](https://doi.org/10.1103/PhysRevLett.123.148005). Rajesh Singh and Michael E. Cates. Phys. Rev. Lett. 123, 148005 (2019). 53 | 54 | * [Self-propulsion of active droplets without liquid-crystalline order](https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.2.032024). Rajesh Singh, Elsen Tjhung, and Michael E. Cates. Phys. Rev. Research 2, 032024(R) (2020). 55 | 56 | 57 | ## News 58 | * Our paper has been highlighted in the Journal Club for Condensed Matter Physics with a [commentary](https://doi.org/10.36471/JCCM_March_2020_01). 59 | 60 | 61 | ## Support 62 | Please use the [issue tracker](https://github.com/rajeshrinet/pygl/issues) on GitHub. 63 | 64 | ## License 65 | We believe that openness and sharing improves the practice of science and increases the reach of its benefits. This code is released under the [MIT license](http://opensource.org/licenses/MIT). Our choice is guided by the excellent article on [Licensing for the scientist-programmer](http://www.ploscompbiol.org/article/info%3Adoi%2F10.1371%2Fjournal.pcbi.1002598). 66 | 67 | 68 | 69 | -------------------------------------------------------------------------------- /docs/Makefile: -------------------------------------------------------------------------------- 1 | # Minimal makefile for Sphinx documentation 2 | # 3 | 4 | # You can set these variables from the command line, and also 5 | # from the environment for the first two. 6 | SPHINXOPTS ?= 7 | SPHINXBUILD ?= sphinx-build 8 | SOURCEDIR = . 9 | BUILDDIR = _build 10 | 11 | # Put it first so that "make" without argument is like "make help". 12 | help: 13 | @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 14 | 15 | .PHONY: help Makefile 16 | 17 | # Catch-all target: route all unknown targets to Sphinx using the new 18 | # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). 19 | %: Makefile 20 | @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) 21 | -------------------------------------------------------------------------------- /docs/changelogs.md: -------------------------------------------------------------------------------- 1 | # PyGL changelogs 2 | 3 | ## 2.0.0 4 | * rename package to pygl 5 | 6 | ## 1.0.0 7 | * first version on PyPI 8 | -------------------------------------------------------------------------------- /docs/conf.py: -------------------------------------------------------------------------------- 1 | # Configuration file for the Sphinx documentation builder. 2 | # 3 | # This file only contains a selection of the most common options. For a full 4 | # list see the documentation: 5 | # https://www.sphinx-doc.org/en/master/usage/configuration.html 6 | 7 | # -- Path setup -------------------------------------------------------------- 8 | 9 | # If extensions (or modules to document with autodoc) are in another directory, 10 | # add these directories to sys.path here. If the directory is relative to the 11 | # documentation root, use os.path.abspath to make it absolute, like shown here. 12 | # 13 | import os 14 | import sys 15 | 16 | # -- Project information ----------------------------------------------------- 17 | 18 | project = 'PyGL' 19 | copyright = '2020, Rajesh Singh' 20 | 21 | 22 | # The full version, including alpha/beta/rc tags 23 | release = '2.0.1' 24 | 25 | 26 | # -- General configuration --------------------------------------------------- 27 | 28 | # Add any Sphinx extension module names here, as strings. They can be 29 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom 30 | # ones. 31 | 32 | extensions = [ 33 | 'sphinx.ext.autodoc', 34 | 'sphinx.ext.coverage', 35 | 'sphinx.ext.napoleon' 36 | # 'numpydoc' 37 | ] 38 | 39 | autodoc_member_order = 'bysource' 40 | autodoc_inherit_docstrings = False 41 | napoleon_numpy_docstring = True 42 | pygments_style = 'sphinx' 43 | 44 | # Add any paths that contain templates here, relative to this directory. 45 | templates_path = ['_templates'] 46 | 47 | # List of patterns, relative to source directory, that match files and 48 | # directories to ignore when looking for source files. 49 | # This pattern also affects html_static_path and html_extra_path. 50 | exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] 51 | 52 | 53 | # -- Options for HTML output ------------------------------------------------- 54 | 55 | # The theme to use for HTML and HTML Help pages. See the documentation for 56 | # a list of builtin themes. 57 | # 58 | html_theme = "sphinx_rtd_theme" 59 | 60 | # Add any paths that contain custom static files (such as style sheets) here, 61 | # relative to this directory. They are copied after the builtin static files, 62 | # so a file named "default.css" will overwrite the builtin "default.css". 63 | master_doc = 'index' 64 | -------------------------------------------------------------------------------- /docs/dms.rst: -------------------------------------------------------------------------------- 1 | Differentiation Matrices 2 | ================================== 3 | 4 | Differentiation matrices using finite differentiation and spectral methods 5 | 6 | Finite Differentiation Matrices 7 | ------------------------------------------------------ 8 | .. autoclass:: pygl.dms.FD 9 | :members: 10 | 11 | 12 | Fourier Spectral Matrices 13 | -------------------------- 14 | .. autoclass:: pygl.dms.FourierSpectral 15 | :members: 16 | 17 | -------------------------------------------------------------------------------- /docs/index.rst: -------------------------------------------------------------------------------- 1 | PyGL API 2 | ================================== 3 | .. image:: ../examples/banner.jpeg 4 | :width: 800 5 | :alt: PyGL banner 6 | 7 | 8 | 9 | `PyGL `_ is a numerical library for statistical field theory in Python. The name GL corresponds to the Ginzburg–Landau theory. The library has been specifically designed to study field theories without time-reversal symmetry. The library can be used to study models of statistical physics of various symmetries and conservation laws. In particular, we allow models with mass and momentum conservations. The library constructs differentiation matrices using finite-difference and spectral methods. To study the role of momentum conservation, the library also allows computing fluid flow from the solution of the Stokes equation. 10 | 11 | Please see installation instructions and more details in the `README.md `_ on GitHub. 12 | 13 | 14 | 15 | 16 | API Reference 17 | ============= 18 | 19 | .. toctree:: 20 | :maxdepth: 1 21 | 22 | 23 | dms 24 | solvers 25 | utils 26 | -------------------------------------------------------------------------------- /docs/make.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | pushd %~dp0 4 | 5 | REM Command file for Sphinx documentation 6 | 7 | if "%SPHINXBUILD%" == "" ( 8 | set SPHINXBUILD=sphinx-build 9 | ) 10 | set SOURCEDIR=. 11 | set BUILDDIR=_build 12 | 13 | if "%1" == "" goto help 14 | 15 | %SPHINXBUILD% >NUL 2>NUL 16 | if errorlevel 9009 ( 17 | echo. 18 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx 19 | echo.installed, then set the SPHINXBUILD environment variable to point 20 | echo.to the full path of the 'sphinx-build' executable. Alternatively you 21 | echo.may add the Sphinx directory to PATH. 22 | echo. 23 | echo.If you don't have Sphinx installed, grab it from 24 | echo.http://sphinx-doc.org/ 25 | exit /b 1 26 | ) 27 | 28 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 29 | goto end 30 | 31 | :help 32 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% 33 | 34 | :end 35 | popd 36 | -------------------------------------------------------------------------------- /docs/solvers.rst: -------------------------------------------------------------------------------- 1 | Stokes flow on a grid 2 | ================================================= 3 | 4 | Stokes flow on a grid in two- and three-dimensions 5 | 6 | .. autoclass:: pygl.solvers.Stokes 7 | :members: 8 | -------------------------------------------------------------------------------- /docs/utils.rst: -------------------------------------------------------------------------------- 1 | Utils 2 | ================================== 3 | 4 | .. automethod:: pygl.utils.azimuthalAverage 5 | 6 | .. automethod:: pygl.utils.azimuthalAverage2 7 | 8 | .. automethod:: pygl.utils.bubble 9 | 10 | .. automethod:: pygl.utils.droplet 11 | 12 | .. automethod:: pygl.utils.ellipseDroplet 13 | 14 | .. automethod:: pygl.utils.structureFactor 15 | 16 | .. automethod:: pygl.utils.structureFactor 17 | 18 | 19 | Differentiation using loops (unlike pygl.dms) 20 | ------------------------------------------------------ 21 | .. autoclass:: pygl.utils.FiniteDifference 22 | :members: 23 | -------------------------------------------------------------------------------- /environment.yml: -------------------------------------------------------------------------------- 1 | name: pygl 2 | channels: 3 | - conda-forge 4 | dependencies: 5 | - python 6 | - jupyter 7 | - numpy 8 | - matplotlib 9 | - cython 10 | - scipy 11 | -------------------------------------------------------------------------------- /examples/amb+.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "9a39de5e-1203-4077-9e2d-b20564021b8c", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import numpy as np\n", 11 | "import pygl, sys, time \n", 12 | "import scipy as sp\n", 13 | "from scipy.io import savemat, loadmat\n", 14 | "from tqdm import trange" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "id": "1f2403a9-793b-468d-a00d-14de455814c9", 20 | "metadata": {}, 21 | "source": [ 22 | "$$\n", 23 | "\\dot{\\phi} +\\boldsymbol{\\nabla}\\cdot\\boldsymbol{J} =0. \n", 24 | "$$\n", 25 | "\n", 26 | "$$\n", 27 | "\\boldsymbol{J} =M\\left(-\\boldsymbol{\\nabla}\\mu+\\zeta(\\nabla^{2}\\phi)\\boldsymbol{\\nabla}\\phi\\right)+\\sqrt{2DM}\\boldsymbol{\\Lambda}, \n", 28 | "$$\n", 29 | "\n", 30 | "$$\n", 31 | "\\mu =\\mu^{E}+\\mu^{\\lambda},\\quad\\mu^{E}=\\frac{\\delta\\mathcal{F}}{\\delta\\phi},\\quad\\mu^{\\lambda}=\\lambda|\\boldsymbol{\\nabla}\\phi|^{2}.\n", 32 | "$$" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 2, 38 | "id": "ccf11642-593d-4e62-9e90-cd2031fc6bc7", 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "class activeModels():\n", 43 | " '''Class to solve a active model B+'''\n", 44 | " def __init__(self, Nt, dt, dd, rhs):\n", 45 | " self.Nt = Nt\n", 46 | " self.dt = dt\n", 47 | " self.dd = dd\n", 48 | " \n", 49 | " self.rhs = rhs \n", 50 | " self.XX = np.zeros((int(self.dd+1), Ng*Ng)) \n", 51 | " \n", 52 | " def integrate(self, u):\n", 53 | " ''' simulates the equation and plots it at different instants '''\n", 54 | " ii=0; t1 = time.perf_counter()\n", 55 | " \n", 56 | " for i in trange(self.Nt): \n", 57 | " u = u + self.dt*self.rhs(u)\n", 58 | " if i%(int(self.Nt/self.dd))==0: \n", 59 | " self.XX[ii,:] = u.flatten()\n", 60 | " ii += 1 " 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 3, 66 | "id": "0628abde-1112-485b-a1fd-d08a9dd2cc7d", 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [ 70 | "# now set-up the simulation \n", 71 | "Ng, zeta = 64, 2 \n", 72 | "\n", 73 | "a, b, k = -0.25, 0.25, 1\n", 74 | "phi0, lmda_a = 0.6 , 1.2\n", 75 | "\n", 76 | "dim, h = 2, 1 \n", 77 | "Nt, dt, dd = int(6e6), .003, 2000\n", 78 | "\n", 79 | "grid = {\"dim\":dim, \"Nx\":Ng, \"Ny\":Ng}\n", 80 | "ff = pygl.utils.FiniteDifference(grid)\n", 81 | "\n", 82 | "#Teff=0.1; nfac=np.sqrt(2*Teff/(h*h*dt))\n", 83 | "nfac=1.6" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 4, 89 | "id": "d278879f-6389-4f23-a69b-cb0b73ee7cdf", 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "def rhs(u):\n", 94 | " '''\n", 95 | " returns the right hand side of active model B+\n", 96 | " ''' \n", 97 | " u_x=ff.diffx(u); u_y=ff.diffy(u); upp=ff.laplacian(u); \n", 98 | " gp2 = (u_x*u_x + u_y*u_y)\n", 99 | "\n", 100 | " chemPot = -.25*u + .25*u*u*u - upp + lmda_a*gp2\n", 101 | "\n", 102 | " Lmdax = nfac*np.random.randn(Ng,Ng)\n", 103 | " Lmday = nfac*np.random.randn(Ng,Ng)\n", 104 | " \n", 105 | " jx = -ff.diffx1(chemPot) + Lmdax + zeta*upp*u_x \n", 106 | " jy = -ff.diffy1(chemPot) + Lmday + zeta*upp*u_y \n", 107 | " du = -ff.diffx1(jx) - ff.diffy1(jy)\n", 108 | " return du " 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 5, 114 | "id": "02246505-5935-4d05-9f23-bc37b90c6bc4", 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "am = activeModels(Nt, dt, dd, rhs)\n", 119 | "u = 0.0*(1-2*np.random.random((Ng, Ng)))\n", 120 | "r1, xb1, yb1 = Ng/8, Ng/4, Ng/2\n", 121 | "r2, xb2, yb2 = Ng/5, 3*Ng/4, Ng/2\n", 122 | "u = pygl.utils.twoBubbles(u, r1, xb1, yb1, r2, xb2, yb2)" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "id": "94262b9f-bebf-4527-abf2-4e953c5243a4", 128 | "metadata": {}, 129 | "source": [ 130 | "## Run the simulation and save data\n" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 6, 136 | "id": "e4303ef7-4595-4367-ba44-21b951796380", 137 | "metadata": {}, 138 | "outputs": [ 139 | { 140 | "name": "stderr", 141 | "output_type": "stream", 142 | "text": [ 143 | "100%|███████████████████████████████| 6000000/6000000 [23:54<00:00, 4181.36it/s]\n" 144 | ] 145 | } 146 | ], 147 | "source": [ 148 | "t1 = time.perf_counter()\n", 149 | "\n", 150 | "am.integrate(u)" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 7, 156 | "id": "5ae770b0-b420-4a07-87d3-518c45e29240", 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [ 160 | "## save data\n", 161 | "savemat('N%s_z%2.2f_l%2.2f_4.4f_u%2.2f_nf%4.4f_bubbp.mat'%(Ng, zeta, lmda_a, phi0, nfac), \n", 162 | " {'X':am.XX, 'a':a, 'b':b, 'k':k, 'Ng':Ng, 'Nt':am.Nt, 'dt':dt, 'nfac':nfac, 'Tsim':time.perf_counter()-t1})" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "id": "f3f78a9d-4cde-4180-90f9-9f720ff79082", 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "id": "c91a6ef4-96f9-4ebf-8fcf-e2fc7057bad1", 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "id": "2608788b-7600-4430-b508-0dba835f9126", 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "id": "3a49735d-9f15-48f0-9a4f-acf8daf24c31", 193 | "metadata": {}, 194 | "outputs": [], 195 | "source": [] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "id": "c838237a-165d-4690-b7c7-3affdc15dca1", 200 | "metadata": {}, 201 | "source": [ 202 | "## Plot snapshots" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": 8, 208 | "id": "e2a71381-0e45-4f1e-9c11-4e0cb09d94e5", 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "import matplotlib.pyplot as plt" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 9, 218 | "id": "3a2dff8e-6934-4fe7-9806-315f180f26fe", 219 | "metadata": {}, 220 | "outputs": [], 221 | "source": [ 222 | "def configPlot(U, fig, n_, i):\n", 223 | " import matplotlib.pyplot as plt\n", 224 | " sp = fig.add_subplot(2, 4, n_ ) \n", 225 | "\n", 226 | " im=plt.pcolor(U, cmap=plt.cm.RdBu_r); plt.clim(-1.1, 1.1);\n", 227 | " cbar = plt.colorbar(im,fraction=0.04, pad=0.05, orientation=\"horizontal\", \n", 228 | " ticks=[-1, 0, 1])\n", 229 | "\n", 230 | " plt.axis('off'); plt.title('T = %1.2E'%(i))" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 10, 236 | "id": "edd7baac-3872-4eb3-a82b-369cc89e1122", 237 | "metadata": {}, 238 | "outputs": [ 239 | { 240 | "data": { 241 | "image/png": "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", 242 | "text/plain": [ 243 | "
" 244 | ] 245 | }, 246 | "metadata": {}, 247 | "output_type": "display_data" 248 | } 249 | ], 250 | "source": [ 251 | "fig = plt.figure(num=None, figsize=(18, 8), dpi=100);\n", 252 | "ti=0; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 1, ti)\n", 253 | "ti=100; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 2, ti)\n", 254 | "ti=200; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 3, ti)\n", 255 | "ti=400; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 4, ti);\n", 256 | "ti=800; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 5, ti);\n", 257 | "ti=1200; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 6, ti);\n", 258 | "ti=1600; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 7, ti);\n", 259 | "ti=1999; configPlot(am.XX[ti,::].reshape(Ng, Ng), fig, 8, ti);" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": null, 265 | "id": "5454daa3-acc0-4d46-b846-c233c2ab401e", 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [] 269 | } 270 | ], 271 | "metadata": { 272 | "kernelspec": { 273 | "display_name": "Python 3 (ipykernel)", 274 | "language": "python", 275 | "name": "python3" 276 | }, 277 | "language_info": { 278 | "codemirror_mode": { 279 | "name": "ipython", 280 | "version": 3 281 | }, 282 | "file_extension": ".py", 283 | "mimetype": "text/x-python", 284 | "name": "python", 285 | "nbconvert_exporter": "python", 286 | "pygments_lexer": "ipython3", 287 | "version": "3.10.9" 288 | } 289 | }, 290 | "nbformat": 4, 291 | "nbformat_minor": 5 292 | } 293 | -------------------------------------------------------------------------------- /examples/amh_b+.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "3fd14445-eae7-44be-a6d0-ee579f350d22", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import numpy as np\n", 11 | "import pygl, sys, time\n", 12 | "import scipy as sp\n", 13 | "from scipy.io import savemat, loadmat\n", 14 | "fft2 = np.fft.fft2\n", 15 | "randn = np.random.randn\n", 16 | "from tqdm import trange\n", 17 | " \n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "id": "ff9c0b8a-0abc-4af3-bbc2-9aa088f24bb2", 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [ 27 | "Ng, nfac, kh = 32, 1, -.001" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 3, 33 | "id": "19b6f3e4-999d-4068-8589-f043606c9ae6", 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "class activeModels():\n", 38 | " '''Class to solve a active models'''\n", 39 | " def __init__(self, Nt, dt, dd, rhs):\n", 40 | " self.Nt = Nt\n", 41 | " self.dt = dt\n", 42 | " self.dd = dd\n", 43 | " \n", 44 | " self.rhs = rhs \n", 45 | " self.XX = np.zeros((int(self.dd+1), Ng*Ng)) \n", 46 | " \n", 47 | " def integrate(self, u):\n", 48 | " ''' simulates the equation and plots it at different instants '''\n", 49 | " ii=0\n", 50 | " #fW = open('N%s_z%2.2f_l%2.2f_kh%4.4f_u%2.2f_a%4.4f_fd.txt'%(Ng, zeta, ll, kh, phi0, a), 'w')\n", 51 | " #fW.write('Ng%s_zeta%s_ ll%s_kh%s_phi0%s_a%s_b%s_k%s_dt%s_nfac%s_Ng%s_Nt%s \\n'%(Ng, zeta, ll, kh, phi0, a, b,k, dt, nfac, Ng, Nt))\n", 52 | " t1 = time.perf_counter()\n", 53 | " \n", 54 | " for i in trange(self.Nt): \n", 55 | " if time.perf_counter() - t1 > 42000:\n", 56 | " break \n", 57 | " u = u + self.dt*self.rhs(u)\n", 58 | " if i%(int(self.Nt/self.dd))==0: \n", 59 | " self.XX[ii,:] = u.flatten()\n", 60 | " ii += 1 \n", 61 | " #fW.write('%s\\n'%u.flatten() )\n", 62 | " \n", 63 | "\n", 64 | "# now set-up the simulation \n", 65 | "a, b, k = -.25, .25, 1\n", 66 | "zeta, ll = 2, -2\n", 67 | "phi0 = .6\n", 68 | "\n", 69 | "dim, h, st = 2, 1, 5\n", 70 | "Nt, dt, dd = int(1e4), .01, 1000 \n", 71 | "Ng2 = Ng*Ng\n", 72 | "\n", 73 | "eta = 1\n", 74 | "grid = {\"dim\":dim, \"Nx\":Ng, \"Ny\":Ng}\n", 75 | "ff = pygl.utils.FiniteDifference(grid)\n", 76 | "stokes = pygl.solvers.Stokes(eta, grid)\n", 77 | "\n", 78 | "Teff=0.1#nfac = Ng*Ng, np.sqrt(2*Teff/(h*h*dt))\n", 79 | "nfac=2\n", 80 | "\n", 81 | "\n", 82 | "def rhs(u):\n", 83 | " '''\n", 84 | " returns the right hand side of \\dot{phi} in active model H\n", 85 | " \\dot{u} = Δ(a*u + b*u*u*u + kΔu + λ(∇u)^2) - v.∇u (solve for fluid)\n", 86 | " '''\n", 87 | " #print( t, np.max(u))\n", 88 | " \n", 89 | " u_x=ff.diffx(u); u_y=ff.diffy(u); upp=ff.laplacian(u); \n", 90 | " gp2 = 0.5*(u_x*u_x + u_y*u_y)\n", 91 | " chemPot = -.25*u + .25*u*u*u - upp + 2*ll*gp2\n", 92 | " jx = -ff.diffx1(chemPot) + nfac*randn(Ng,Ng) + zeta*upp*u_x \n", 93 | " jy = -ff.diffy1(chemPot) + nfac*randn(Ng,Ng) + zeta*upp*u_y \n", 94 | " du = ff.diffx1(jx) + ff.diffy1(jy)\n", 95 | "\n", 96 | " sxx = u_x*u_x-gp2; sxy=u_x*u_y; syy=u_y*u_y-gp2;\n", 97 | " fx = ff.diffx(sxx) + ff.diffy(sxy)\n", 98 | " fy = ff.diffx(sxy) + ff.diffy(syy)\n", 99 | "\n", 100 | " stokes.solve((fft2(fx), fft2(fy)))\n", 101 | " return -du - kh*(u_x*stokes.vx + u_y*stokes.vy)" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 4, 107 | "id": "fab627b6-513b-46ac-968b-55a0c046afcb", 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stderr", 112 | "output_type": "stream", 113 | "text": [ 114 | "100%|███████████████████████████████████| 10000/10000 [00:01<00:00, 5565.74it/s]\n" 115 | ] 116 | } 117 | ], 118 | "source": [ 119 | "am = activeModels(Nt, dt, dd, rhs)\n", 120 | "u = phi0 + .0*(1-2*np.random.random((Ng, Ng)))\n", 121 | "\n", 122 | "# run the simulation and save data\n", 123 | "t1 = time.perf_counter()\n", 124 | "am.integrate(u)\n", 125 | "savemat('N%s_z%2.2f_l%2.2f_kh%4.4f_u%2.2f_nf%4.4f_ambp.mat'%(Ng, zeta, ll, kh, phi0, nfac), {'X':am.XX, 'a':a, 'b':b, 'k':k, 'Ng':Ng, 'Nt':am.Nt, 'dt':dt, 'nfac':nfac, 'Tsim':time.perf_counter()-t1})" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "id": "e1343148-2050-42d1-bc4f-bd5cc4411bc4", 132 | "metadata": {}, 133 | "outputs": [], 134 | "source": [] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": null, 139 | "id": "7a6044f0-cafc-483b-991d-bba77b58b22e", 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [] 143 | } 144 | ], 145 | "metadata": { 146 | "kernelspec": { 147 | "display_name": "Python 3 (ipykernel)", 148 | "language": "python", 149 | "name": "python3" 150 | }, 151 | "language_info": { 152 | "codemirror_mode": { 153 | "name": "ipython", 154 | "version": 3 155 | }, 156 | "file_extension": ".py", 157 | "mimetype": "text/x-python", 158 | "name": "python", 159 | "nbconvert_exporter": "python", 160 | "pygments_lexer": "ipython3", 161 | "version": "3.10.9" 162 | } 163 | }, 164 | "nbformat": 4, 165 | "nbformat_minor": 5 166 | } 167 | -------------------------------------------------------------------------------- /examples/banner.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rajeshrinet/pygl/1f730792b65469a59b336e99371c826e0cc21fd1/examples/banner.jpeg -------------------------------------------------------------------------------- /makefile: -------------------------------------------------------------------------------- 1 | PYTHON=python 2 | path=examples 3 | recursive=True 4 | 5 | make: 6 | @echo Installing pygl... 7 | ${PYTHON} setup.py install 8 | 9 | clean-local: 10 | @echo removing local compiled files 11 | rm pygl/*.c pygl/*.html pygl/*.cpp 12 | 13 | clean: 14 | @echo removing all compiled files 15 | ${PYTHON} setup.py clean 16 | rm pygl/*.c pygl/*.html 17 | 18 | env: 19 | @echo creating conda environment... 20 | conda env create --file environment.yml 21 | # conda activate pygl 22 | @echo use make to install pygl 23 | 24 | test: 25 | @echo testing pygl... 26 | cd pygl/tests/ && python installTests.py 27 | 28 | nbtest: 29 | @echo testing example notebooks... 30 | @echo test $(path) 31 | cd pygl/tests/ && python testNotebooks.py 32 | 33 | 34 | pypitest: 35 | @echo testing pystokes... 36 | python setup.py sdist bdist_wheel 37 | python -m twine upload --repository testpypi dist/* 38 | 39 | pypi: 40 | @echo testing pystokes... 41 | python setup.py sdist bdist_wheel 42 | python -m twine upload dist/* 43 | 44 | -------------------------------------------------------------------------------- /pygl/__init__.py: -------------------------------------------------------------------------------- 1 | import pygl.dms 2 | import pygl.models 3 | import pygl.solvers 4 | import pygl.utils 5 | 6 | ## latest version of PyGL 7 | __version__="2.2.0" 8 | -------------------------------------------------------------------------------- /pygl/dms.pyx: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | cimport numpy as np 3 | cimport cython 4 | from libc.math cimport sqrt, pow 5 | cdef double PI = 3.14159265359 6 | from scipy.sparse import spdiags 7 | DTYPE = np.float64 8 | ctypedef np.float_t DTYPE_t 9 | 10 | 11 | 12 | @cython.wraparound(False) 13 | @cython.boundscheck(False) 14 | @cython.cdivision(True) 15 | cdef class FD: 16 | ''' 17 | Finite Differenc (central) NxN differentiation matrix (DM) 18 | ''' 19 | cdef: 20 | readonly int N, s, st 21 | readonly double h, facy, facz 22 | readonly np.ndarray data, stp, beta, weights, data0, diagsL, diagsU 23 | 24 | 25 | def __init__(self, int N, int s, double h): 26 | ''' 27 | N, s, h = grid, #stencil points (odd), grid spacing 28 | ''' 29 | self.N = N 30 | self.s = s 31 | self.h = h 32 | self.st = int(s/2.0-1.0/2.0) 33 | 34 | self.data0 = np.ones((s, N), dtype=DTYPE) 35 | self.data = np.zeros((s, N), dtype=DTYPE) 36 | self.stp = np.arange(-self.st, self.st + 1, dtype=DTYPE) # stencil points 37 | self.beta = np.ones((self.s), dtype=DTYPE) 38 | self.weights = np.zeros((self.s), dtype=DTYPE) 39 | 40 | self.diagsL = np.arange(-(N-1), -(N-1)+self.st, 1) # lower circulant for PBC 41 | self.diagsU = np.arange(N-self.st, N, 1) # upper circulant 42 | 43 | 44 | cpdef diffmat(self, int m): 45 | ''' 46 | m-th order differentiation matrix using central differences. 47 | ''' 48 | cdef int N=self.N, s=self.N, st=self.st 49 | 50 | self.diffweight(m) 51 | D = spdiags(self.data, self.stp, N, N) 52 | 53 | #ensure PBC 54 | D += spdiags(self.data[st+1:s,:],self.diagsL,N,N) + spdiags(self.data[0:st,:],self.diagsU,N,N) 55 | 56 | # scale by grid resolution 57 | D = D/(self.h**m) 58 | 59 | return D 60 | 61 | 62 | cpdef diffweight(self, int m): 63 | ''' 64 | *weights of the m-th order derivative using central Difference 65 | *this can be read from the table if the code needs to be made fast 66 | *first generate the table using the code! 67 | Read more: Bengt Fornberg SIAM Review, Vol. 40, No. 3 (Sep., 1998) 68 | Calculation of Weights in Finite Difference Formulas 69 | ''' 70 | cdef int i, j, k, ii, jj 71 | wts=np.zeros((m+1, self.s), dtype=DTYPE) 72 | cdef double b0=1, bb, ihm=1.0/pow(self.h, m) 73 | for i in range(1, self.s): 74 | self.beta[i] = np.prod(self.stp[i]-self.stp[0:i]) 75 | cdef double [:] bt = self.beta 76 | cdef double [:,:] ww = wts 77 | cdef double [:,:] d0 = self.data0 78 | cdef double [:,:] d1 = self.data 79 | cdef double [:] stp = self.stp 80 | 81 | ww[0,0] = 1. 82 | for i in range(1, self.s): 83 | jj = min(i, m)+1; bb=b0/bt[i] 84 | for k in range(jj): 85 | ww[k, i] = bb*(k*ww[k-1,i-1]-(stp[i-1])*ww[k,i-1]) 86 | b0 = bt[i] 87 | 88 | for j in range(i): 89 | for k in range(min(i,m),-1,-1): 90 | ww[k,j] = ((stp[i])*ww[k,j]-k*ww[k-1,j])/(stp[i]-stp[j]) 91 | 92 | for i in range(self.s): 93 | for j in range(self.N): 94 | d1[i,j] = d0[i,j] * ww[m, i] * ihm 95 | self.weights = wts[m, :] 96 | return 97 | 98 | 99 | 100 | 101 | @cython.wraparound(False) 102 | @cython.boundscheck(False) 103 | @cython.cdivision(True) 104 | cdef class FourierSpectral: 105 | ''' 106 | Spectral method using Fourier tranform to compute differentiation matrices (DM) 107 | ''' 108 | cdef: 109 | readonly int Nx, Ny, dim 110 | readonly double h, facy, facz 111 | readonly np.ndarray data, kx, ky, ksq 112 | 113 | 114 | def __init__(self, grid): 115 | ''' 116 | grid is the argument 117 | ''' 118 | self.dim = grid.get('dim') 119 | 120 | 121 | if self.dim == 1: 122 | self.Nx = grid.get('Nx') 123 | self.kx = 2*np.pi*np.fft.fftfreq(self.Nx) 124 | self.ksq = self.kx*self.kx 125 | 126 | elif self.dim == 2: 127 | self.Nx, self.Ny = grid.get('Nx'), grid.get('Ny') 128 | kxx = 2*np.pi*np.fft.fftfreq(self.Nx) 129 | kyy = 2*np.pi*np.fft.fftfreq(self.Ny) 130 | self.kx, self.ky = np.meshgrid(kxx, kyy) 131 | self.ksq = self.kx*self.kx + self.ky*self.ky 132 | 133 | 134 | cpdef diffmat(self, int m): 135 | ''' 136 | m-th order differentiation matrix using FourierSpectral 137 | ''' 138 | if self.dim==1: 139 | if m==1: 140 | D = 1j*self.kx 141 | elif m==2: 142 | D = -self.kx*self.kx 143 | else: 144 | print ('construct using combination of 1 and 2!') 145 | 146 | elif self.dim==2: 147 | if m==1: 148 | D = (1j*self.kx, 1j*self.ky) 149 | elif m==2: 150 | D = -(self.kx*self.kx + self.ky*self.ky) 151 | else: 152 | print ('construct using combination of 1 and 2!') 153 | 154 | else: 155 | print ('to implement 3D soon!') 156 | return D 157 | 158 | 159 | cpdef dealias(self, double kDA): 160 | ''' 161 | dealias operator 162 | kDA: fraction of the wavectors which are not set to zero 163 | ''' 164 | kxx = 2*np.pi*np.fft.fftfreq(self.Nx) 165 | kyy = 2*np.pi*np.fft.fftfreq(self.Ny) 166 | kx, ky = np.meshgrid(kxx, kyy) 167 | 168 | kmax = kDA*np.max(np.abs(kx)) 169 | 170 | filtr1 = np.ones_like(kx) 171 | filtr2 = np.ones_like(ky) 172 | 173 | filtr1[np.where(np.abs(kx)>kmax)] = 0. 174 | filtr2[np.where(np.abs(ky)>kmax)] = 0. 175 | 176 | return filtr1*filtr2 177 | -------------------------------------------------------------------------------- /pygl/models.py: -------------------------------------------------------------------------------- 1 | from scipy.io import savemat 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | from numpy import pi 5 | from tqdm import tqdm 6 | from matplotlib.animation import FuncAnimation 7 | 8 | import scipy.fft 9 | FFT = scipy.fft.fft2 10 | IFFT = scipy.fft.ifft2 11 | 12 | fft2 = np.fft.fft2 13 | ifft2 = np.fft.ifft2 14 | randn = np.random.randn 15 | 16 | 17 | 18 | class FPS_ModelB(): 19 | '''Class to simulate field theories using a PSEUDO-SPECTRAL TECHNIQUE WITH FILTERING''' 20 | def __init__(self, param): 21 | self.Nt = param['Nt']; self.dt=param['dt']; self.Nf = param['Nf'] 22 | self.h = param['h']; self.a = param['a']; self.b = param['b'] 23 | self.kp = param['kp']; self.k_tilde= param['k_tilde']; self.Ng= param['Ng'] 24 | self.Df = 1j*param['Df']; Ng = self.Ng 25 | self.k_c= param['k_c'] 26 | 27 | self.XX = np.zeros((int(self.Nf+1), Ng*Ng)); 28 | self.LL = np.zeros((int(self.Nf+1), Ng*Ng)); 29 | 30 | qf=np.fft.fftfreq(Ng)*(2*np.pi/self.h) 31 | self.qx, self.qy = np.meshgrid(qf, qf) 32 | self.Dx, self.Dy = 1j*self.qx, 1j*self.qy 33 | 34 | self.q2 = self.qx*self.qx + self.qy*self.qy; 35 | alpha_q = -self.q2*(self.a + self.kp*self.q2)*self.dt; 36 | self.eA = np.exp(alpha_q); self.q2b=self.q2*self.b 37 | 38 | iq2=1/(self.q2+1e-16); iq2[0,0]=0; self.iq2=iq2 39 | self.iQ2x, self.iQ2y = self.qx*iq2, self.qy*iq2 40 | self.qmod = np.sqrt( (self.q2) ) 41 | 42 | freqs = (2*np.pi)*np.fft.fftfreq(Ng) 43 | self.kx_s = np.fft.fftshift(freqs) 44 | 45 | def integrate(self, u): 46 | ''' simulates the equation and plots it at different instants ''' 47 | ii=0; t=0; dt=self.dt; Df=self.Df; simC=(100/self.Nt) 48 | self.u=u 49 | for i in tqdm(range(self.Nt)): 50 | self.rhs() 51 | if i%(int(self.Nt/self.Nf))==0: 52 | self.XX[ii,:] = (np.real(ifft2(self.u))).flatten() 53 | ii += 1 54 | 55 | 56 | def rhs(self): 57 | ''' 58 | integrator to simulate the dynamics of order paramter 59 | using filtere-pseudo-spectral (FPS) 60 | ''' 61 | ## evolve the order paramter using FPS 62 | uc = ifft2(self.u); 63 | N_u = -self.q2b*fft2(uc*uc*uc) 64 | 65 | self.u = (self.u + N_u*self.dt)*(self.eA) 66 | return 67 | 68 | 69 | def getLength(self): 70 | u1 = np.abs( (self.u) ); 71 | a2, b2 = avgFuncKspace(u1*u1/(Ng*Ng), self.qmod, int(self.Ng/4)) 72 | 73 | LL = 2*np.pi*np.sum(b2)/np.sum(a2*b2) 74 | print (np.max(a2), np.max(b2), LL) 75 | return LL 76 | 77 | 78 | def structureFactor(self, u, dim): 79 | ''' 80 | Computes S(k) = given the u(r) 81 | This is computed using FFT of u to obtain u(k) 82 | A multiplication of u(k)u(-k) is same as (abs(u(k)))^2 83 | if the field u is real using the definition of complex numbers 84 | ''' 85 | if dim==1: 86 | uk = np.fft.fft(u) 87 | uk = np.fft.fftshift(uk) 88 | uu = np.abs(uk) 89 | 90 | if dim==2: 91 | uk = np.fft.fft2(u) 92 | uk = np.fft.fftshift(uk) 93 | uu = np.abs(uk) 94 | 95 | if dim==3: 96 | uk = np.fft.fftn(u) 97 | uk = np.fft.fftshift(uk) 98 | uu = np.abs(uk) 99 | 100 | return (uu*uu) 101 | 102 | 103 | 104 | def avgFunc(self, u, bins, dim): 105 | if dim==2: 106 | Nx, Ny = np.shape(u) 107 | # xx, yy = np.meshgrid(np.arange(-Nx/2, Nx/2),np.arange(-Ny/2, Ny/2)) 108 | # rr = np.sqrt(xx*xx + yy*yy) 109 | kx = self.kx_s 110 | kx, ky = np.meshgrid(kx,kx); 111 | k2 = kx*kx + ky*ky; k4=k2*k2 ; 112 | ksq= np.fft.fftshift((k2)) 113 | rr = np.sqrt(ksq) 114 | 115 | if dim==3: 116 | Nx, Ny, Nz = np.shape(u) 117 | kx = self.kx_s 118 | xx, yy, zz = np.meshgrid(kx, kx, kx) 119 | rr = np.sqrt(xx*xx + yy*yy + zz*zz) 120 | 121 | 122 | rr = rr.flatten() 123 | rs = np.sort(rr) 124 | ri = np.argsort(rr) 125 | 126 | u = u.flatten(); ua = np.zeros(bins) 127 | u = u[ri] 128 | 129 | ht, bns = np.histogram(rs, bins) 130 | bn = 0.5*(bns[:-1] + bns[1:]) 131 | hm = np.cumsum(ht) 132 | 133 | ua[0] = np.mean( u[0:ht[0]] ) 134 | ua[bins-1] = np.mean( u[bins-1-ht[bins-1]:] ) 135 | for i in range(1, bins-1): 136 | ua[i] = np.mean( u[hm[i]+1:hm[i+1]]) 137 | return ua, bn 138 | 139 | -------------------------------------------------------------------------------- /pygl/solvers.pyx: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | cimport numpy as np 3 | cimport cython 4 | from libc.math cimport sqrt, pow, log, sin, cos, exp 5 | from cython.parallel import prange 6 | 7 | cdef double PI = 3.14159265359 8 | fft2 = np.fft.fft2 9 | ifft2 = np.fft.ifft2 10 | randn = np.random.randn 11 | 12 | cdef extern from "stdlib.h" nogil: 13 | double drand48() 14 | void srand48(long int seedval) 15 | 16 | cdef extern from "time.h": 17 | long int time(int) 18 | srand48(time(0)) 19 | 20 | cdef double gaussianRn() nogil: 21 | cdef int iset = 0; 22 | cdef double fac, rsq, v1, v2; 23 | 24 | if (iset == 0): 25 | v1 = 2.0*drand48()-1.0; 26 | v2 = 2.0*drand48()-1.0; 27 | rsq = v1*v1 + v2*v2; 28 | while (rsq >= 1.0 or rsq == 0.0): 29 | v1 = 2.0*drand48()-1.0; 30 | v2 = 2.0*drand48()-1.0; 31 | rsq = v1*v1 + v2*v2; 32 | fac = sqrt(-2.0*log(rsq)/rsq); 33 | iset = 1 34 | return v2*fac 35 | else: 36 | iset = 0 37 | return v1*fac 38 | 39 | 40 | def getRN(): 41 | return (gaussianRn()) 42 | 43 | DTYPE = np.float64 44 | ctypedef np.float_t DTYPE_t 45 | @cython.wraparound(False) 46 | @cython.boundscheck(False) 47 | @cython.cdivision(True) 48 | cdef class Stokes: 49 | """ 50 | Numerical solution of Stokes equation on 2D or 3D grid. 51 | 52 | ... 53 | 54 | Parameters 55 | ---------- 56 | eta: float 57 | Viscosity of the fluid (eta) 58 | grid: dict 59 | Grid and its properties as a dict 60 | 61 | Example 62 | ---------- 63 | >>> import pygl 64 | >>> eta = .1 65 | >>> grid = {"dim":2, "Nx":32, "Ny":32} 66 | >>> stokes = pygl.solvers.Stokes(eta, grid) 67 | 68 | """ 69 | 70 | 71 | cdef: 72 | readonly int Np, Nx, Ny, Nz, dim, NN 73 | readonly double facx, facy, facz , eta 74 | readonly np.ndarray vx, vy, vz, fkx, fky, fkz, vkx, vky, vkz 75 | 76 | def __init__(self, eta, grid): 77 | 78 | self.dim = grid.get('dim') 79 | self.eta = eta 80 | 81 | if self.dim == 2: 82 | self.Nx, self.Ny = grid.get('Nx'), grid.get('Ny') 83 | self.facx = 2*PI/self.Nx 84 | self.facy = 2*PI/self.Ny 85 | 86 | self.vx = np.empty((self.Nx, self.Ny)) 87 | self.vy = np.empty((self.Nx, self.Ny)) 88 | self.fkx = np.empty((self.Nx, self.Ny), dtype=np.complex128) 89 | self.fky = np.empty((self.Nx, self.Ny), dtype=np.complex128) 90 | self.vkx = np.empty((self.Nx, self.Ny), dtype=np.complex128) 91 | self.vky = np.empty((self.Nx, self.Ny), dtype=np.complex128) 92 | 93 | elif self.dim == 3: 94 | self.Nx, self.Ny, self.Nz = grid.get('Nx'), grid.get('Ny'), grid.get('Nz') 95 | self.facx = 2*PI/self.Nx 96 | self.facy = 2*PI/self.Ny 97 | self.facz = 2*PI/self.Nz 98 | 99 | self.vx = np.empty((self.Nx, self.Ny, self.Nz)) 100 | self.vy = np.empty((self.Nx, self.Ny, self.Nz)) 101 | self.vz = np.empty((self.Nx, self.Ny, self.Nz)) 102 | self.fkx = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 103 | self.fky = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 104 | self.fkz = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 105 | self.vkx = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 106 | self.vky = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 107 | self.vkz = np.empty((self.Nx, self.Ny, self.Nz), dtype=np.complex128) 108 | 109 | else: 110 | raise Exception('Current support is only for 2D or 3D') 111 | 112 | 113 | cpdef solve(self, fk): 114 | """ 115 | Compute flow given force per unit area 116 | 117 | self.vx, self.vy and self.vz contains the flow computed 118 | 119 | ... 120 | 121 | Parameters 122 | ---------- 123 | fk: np.array 124 | Fourier transform of the force per unit area on the grid 125 | 126 | Example 127 | ---------- 128 | >>> import pygl 129 | >>> eta = .1 130 | >>> grid = {"dim":2, "Nx":32, "Ny":32} 131 | >>> stokes = pygl.solvers.Stokes(eta, grid) 132 | >>> fkx = np.random.random((32, 32)) 133 | >>> fky = np.random.random((32, 32)) 134 | >>> stokes.solve( (fkx, fky) ) 135 | """ 136 | 137 | cdef int dim = self.dim 138 | if dim == 2: 139 | self._solve2d(fk) 140 | 141 | elif dim == 3: 142 | self._solve3d(fk) 143 | return 144 | 145 | 146 | cdef _solve2d(self, fk): 147 | 148 | self.fkx = fk[0] 149 | self.fky = fk[1] 150 | 151 | cdef: 152 | complex [:,:] fkx = self.fkx 153 | complex [:,:] fky = self.fky 154 | complex [:,:] vkx = self.vkx 155 | complex [:,:] vky = self.vky 156 | 157 | int jx, jy, Nx, Ny 158 | double facx, facy, iksq, kx, ky, ieta 159 | double complex fdotk 160 | Nx = self.Nx 161 | Ny = self.Ny 162 | 163 | facx = self.facx 164 | facy = self.facy 165 | ieta = 1.0/self.eta 166 | 167 | for jy in range(Ny): 168 | ky = jy*facy if jy<=Ny/2 else (-Ny+jy)*facy 169 | for jx in range(Nx): 170 | kx = jx*facx if jx<=Nx/2 else (-Nx+jx)*facx 171 | if kx == 0 and ky == 0: 172 | iksq = 0.0 173 | else: 174 | iksq = 1.0/(kx*kx + ky*ky) 175 | fdotk = kx*fkx[jy, jx] + ky*fky[jy, jx] 176 | 177 | vkx[jy, jx] = ( fkx[jy, jx] - fdotk*kx*iksq )*iksq*ieta 178 | vky[jy, jx] = ( fky[jy, jx] - fdotk*ky*iksq )*iksq*ieta 179 | 180 | vkx[0, 0] = 0.0 #the integral of the fluid flow vanishes 181 | vky[0, 0] = 0.0 182 | 183 | self.vx = np.real(np.fft.ifft2(self.vkx)) 184 | self.vy = np.real(np.fft.ifft2(self.vky)) 185 | return 186 | 187 | 188 | cdef _solve3d(self, fk): 189 | self.fkx = fk[0] 190 | self.fky = fk[1] 191 | self.fkz = fk[2] 192 | 193 | cdef: 194 | complex [:,:,:] fkx = self.fkx 195 | complex [:,:,:] fky = self.fky 196 | complex [:,:,:] fkz = self.fkz 197 | complex [:,:,:] vkx = self.vkx 198 | complex [:,:,:] vky = self.vky 199 | complex [:,:,:] vkz = self.vkz 200 | 201 | int jx, jy, jz, Nx, Ny, Nz 202 | double facx, facy, facz, iksq, kx, ky, kz, ieta 203 | double complex fdotk 204 | Nx = self.Nx 205 | Ny = self.Ny 206 | Nz = self.Nz 207 | 208 | facx = self.facx 209 | facy = self.facy 210 | facz = self.facz 211 | ieta = 1.0/self.eta 212 | 213 | for jz in range(Nz): 214 | for jy in range(0, Ny): 215 | for jx in range(0, Nx): 216 | kx = jx*facx if jx <= Nx / 2 else (-Nx+jx)*facx 217 | ky = jy*facy if jy <= Ny / 2 else (-Ny+jy)*facy 218 | kz = jz*facz if jz <= Nz / 2 else (-Nz+jz)*facz 219 | 220 | if kx == 0 and ky == 0: 221 | iksq = 0.0 222 | else: 223 | iksq = 1.0/(kx*kx + ky*ky) 224 | fdotk = kx*fkx[jz, jy, jx] + ky*fky[jz, jy, jx] + kz*fkz[jz, jy, jx] 225 | 226 | vkx[jy, jx, jz] = ( fkx[jy, jx, jz] - fdotk*kx*iksq )*iksq*ieta 227 | vky[jy, jx, jz] = ( fky[jy, jx, jz] - fdotk*ky*iksq )*iksq*ieta 228 | vkz[jy, jx, jz] = ( fkz[jy, jx, jz] - fdotk*kz*iksq )*iksq*ieta 229 | 230 | vkx[0, 0, 0] = 0.0 #the integral of the fluid flow vanishes 231 | vky[0, 0, 0] = 0.0 232 | vkz[0, 0, 0] = 0.0 233 | 234 | self.vx = np.real(np.fft.ifftn(self.vkx)) 235 | self.vy = np.real(np.fft.ifftn(self.vky)) 236 | self.vz = np.real(np.fft.ifftn(self.vkz)) 237 | 238 | return -------------------------------------------------------------------------------- /pygl/tests/installTests.py: -------------------------------------------------------------------------------- 1 | """ 2 | Unittesting for the pygl module. 3 | """ 4 | import sys 5 | import pystokes 6 | import unittest 7 | import inspect 8 | import numpy as np 9 | import scipy as sp 10 | 11 | 12 | 13 | if __name__ == '__main__': 14 | unittest.main() 15 | -------------------------------------------------------------------------------- /pygl/tests/testNotebooks.py: -------------------------------------------------------------------------------- 1 | import datetime, os, re, subprocess, sys, argparse, time, unittest 2 | 3 | 4 | ignoreFlag=True # change to False if not to ignore 5 | 6 | 7 | def run_notebook_tests(path, recursive=False): 8 | """ 9 | Runs Jupyter notebook tests. Exits if they fail. 10 | """ 11 | basepath = os.path.dirname(__file__) 12 | nbpath = os.path.abspath(os.path.join(basepath, "../..", path)) 13 | ''' 14 | Ignore notebooks which take longer or have deliberate errors, 15 | but check they still exists 16 | ''' 17 | os.chdir('../../examples/') 18 | 19 | cwd =os.getcwd() 20 | ignore_list = [ 21 | ] 22 | 23 | for ignored_book in ignore_list: 24 | if not os.path.isfile(ignored_book): 25 | raise Exception('Ignored notebook not found: ' + ignored_book) 26 | 27 | # Scan and run 28 | print('Testing notebooks') 29 | ok = True 30 | for notebook, cwd in list_notebooks(nbpath, recursive, ignore_list): 31 | os.chdir(cwd) # necessary for relative imports in notebooks 32 | ok &= test_notebook(notebook) 33 | # print(notebook) 34 | if not ok: 35 | print('\nErrors encountered in notebooks') 36 | sys.exit(1) 37 | print('\nOK') 38 | 39 | 40 | def list_notebooks(root, recursive=False, ignore_list=None, notebooks=None): 41 | """ 42 | Returns a list of all notebooks in a directory. 43 | """ 44 | if notebooks is None: 45 | notebooks = [] 46 | if ignore_list is None or ignoreFlag==False: 47 | ignore_list = [] 48 | try: 49 | for filename in os.listdir(root): 50 | path = os.path.join(root, filename) 51 | cwd = os.path.dirname(path) 52 | if path in ignore_list: 53 | print('Skipping ignored notebook: ' + path) 54 | continue 55 | 56 | # Add notebooks 57 | if os.path.splitext(path)[1] == '.ipynb': 58 | notebooks.append((path,cwd)) 59 | 60 | # Recurse into subdirectories 61 | elif recursive and os.path.isdir(path): 62 | # Ignore hidden directories 63 | if filename[:1] == '.': 64 | continue 65 | list_notebooks(path, recursive, ignore_list, notebooks) 66 | except NotADirectoryError: 67 | path = root 68 | cwd = os.path.dirname(path) 69 | return [(path,cwd)] 70 | 71 | return notebooks 72 | 73 | 74 | def test_notebook(path): 75 | """ 76 | Tests a notebook in a subprocess, exists if it doesn't finish. 77 | """ 78 | import nbconvert 79 | print('Running ' + path + ' ... ', end='') 80 | sys.stdout.flush() 81 | 82 | # Load notebook, convert to python 83 | e = nbconvert.exporters.PythonExporter() 84 | code, __ = e.from_filename(path) 85 | 86 | # Remove coding statement, if present 87 | ipylines = ['ipython', 'show('] 88 | code = '\n'.join([x for x in code.splitlines() if not 'ipython' in x]) 89 | for x in code.splitlines(): 90 | if not any(s in ipylines for s in x): 91 | code += '\n'.join([x]) 92 | # print(code) 93 | 94 | # Tell matplotlib not to produce any figures 95 | env = os.environ.copy() 96 | env['MPLBACKEND'] = 'Template' 97 | 98 | # Run in subprocess 99 | start = time.time() 100 | cmd = [sys.executable, '-c', code] 101 | try: 102 | p = subprocess.Popen( 103 | cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env 104 | ) 105 | stdout, stderr = p.communicate() 106 | # TODO: Use p.communicate(timeout=3600) if Python3 only 107 | if p.returncode != 0: 108 | # Show failing code, output and errors before returning 109 | print('ERROR') 110 | # print('-- script ' + '-' * (79 - 10)) 111 | # for i, line in enumerate(code.splitlines()): 112 | # j = str(1 + i) 113 | # print(j + ' ' * (5 - len(j)) + line) 114 | print('-- stdout ' + '-' * (79 - 10)) 115 | print(stdout) 116 | print('-- stderr ' + '-' * (79 - 10)) 117 | print(stderr) 118 | print('-' * 79) 119 | return False 120 | except KeyboardInterrupt: 121 | p.terminate() 122 | stop = time.time() 123 | print('ABORTED after', round(stop-start,4), "s") 124 | sys.exit(1) 125 | 126 | # Successfully run 127 | stop = time.time() 128 | print('ok. Run took ', round(stop-start,4), "s") 129 | return True 130 | 131 | 132 | def export_notebook(ipath, opath): 133 | """ 134 | Exports the notebook at `ipath` to a python file at `opath`. 135 | """ 136 | import nbconvert 137 | from traitlets.config import Config 138 | 139 | # Create nbconvert configuration to ignore text cells 140 | c = Config() 141 | c.TemplateExporter.exclude_markdown = True 142 | 143 | # Load notebook, convert to python 144 | e = nbconvert.exporters.PythonExporter(config=c) 145 | code, __ = e.from_filename(ipath) 146 | 147 | # Remove "In [1]:" comments 148 | r = re.compile(r'(\s*)# In\[([^]]*)\]:(\s)*') 149 | code = r.sub('\n\n', code) 150 | 151 | # Store as executable script file 152 | with open(opath, 'w') as f: 153 | f.write('#!/usr/bin/env python') 154 | f.write(code) 155 | os.chmod(opath, 0o775) 156 | 157 | 158 | if __name__ == '__main__': 159 | # Set up argument parsing 160 | def str2bool(v): 161 | if isinstance(v, bool): 162 | return v 163 | if v.lower() in ('yes', 'true', 't', 'y', '1'): 164 | return True 165 | elif v.lower() in ('no', 'false', 'f', 'n', '0'): 166 | return False 167 | else: 168 | raise argparse.ArgumentTypeError('Boolean value expected.') 169 | parser = argparse.ArgumentParser( 170 | description='Run notebook unit tests for PyStokes.', 171 | ) 172 | # Unit tests 173 | parser.add_argument( 174 | '--path', default = '.', 175 | help='Run specific notebook or folder containing notebooks',) 176 | parser.add_argument( 177 | '--recursive', default = True, type=str2bool, 178 | help='Wheither or not subfolders are searched',) 179 | 180 | # Parse! 181 | args = parser.parse_args() 182 | print(args) 183 | run_notebook_tests(args.path, recursive=args.recursive) 184 | -------------------------------------------------------------------------------- /pygl/utils.pyx: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | cimport numpy as np 3 | cimport cython 4 | from libc.math cimport sqrt, pow, log 5 | cdef double PI = 3.1415926535 6 | from scipy.sparse import spdiags 7 | 8 | cdef extern from "stdlib.h" nogil: 9 | double drand48() 10 | void srand48(long int seedval) 11 | 12 | cdef extern from "time.h": 13 | long int time(int) 14 | # srand48(time(0)) 15 | srand48(100) 16 | 17 | DTYPE = np.float64 18 | DTYP1 = np.int32 19 | ctypedef np.float_t DTYPE_t 20 | 21 | 22 | ##----------------------------------------------------------- 23 | ## Obtain structureFactor and radial profiles of a field u 24 | ##----------------------------------------------------------- 25 | cpdef structureFactor(u, dim): 26 | """ 27 | * Computes S(k) = given the u(r) 28 | * This is computed using FFT of u to obtain u(k) 29 | * For a real field u, the multiplication of u(k)u(-k) 30 | is same as (abs(u(k)))^2 31 | 32 | 33 | Parameters 34 | ---------- 35 | u: A field on a grid in dim dimensions 36 | dim: dimensionality 37 | 38 | Returns 39 | ------- 40 | structureFactor defined (abs(u(k)))^2/N^2 41 | """ 42 | 43 | 44 | if dim==1: 45 | uk = np.fft.fft(u) 46 | uk = np.fft.fftshift(uk) 47 | uu = np.abs(uk) 48 | 49 | if dim==2: 50 | uk = np.fft.fft2(u) 51 | uk = np.fft.fftshift(uk) 52 | u2 = np.abs(uk*uk) 53 | 54 | if dim==3: 55 | uk = np.fft.fftn(u) 56 | uk = np.fft.fftshift(uk) 57 | u2 = np.abs(uk*uk) 58 | 59 | return u2/(np.size(u)) 60 | 61 | 62 | 63 | def avgStructFunc(u, bins, dim): 64 | if dim==2: 65 | Nx, Ny = np.shape(u) 66 | # xx, yy = np.meshgrid(np.arange(-Nx/2, Nx/2),np.arange(-Ny/2, Ny/2)) 67 | # rr = np.sqrt(xx*xx + yy*yy) 68 | kx = (2*np.pi)*np.fft.fftfreq(Nx) 69 | kx, ky = np.meshgrid(kx,kx); 70 | k2 = kx*kx + ky*ky; k4=k2*k2 ; 71 | ksq= np.fft.fftshift((k2)) 72 | rr = np.sqrt(ksq) 73 | 74 | if dim==3: 75 | Nx, Ny, Nz = np.shape(u) 76 | xx, yy, zz = np.meshgrid(np.arange(-Nx/2, Nx/2),np.arange(-Ny/2, Ny/2),np.arange(-Nz/2, Nz/2)) 77 | rr = np.sqrt(xx*xx + yy*yy + zz*zz) 78 | 79 | 80 | rr = rr.flatten() 81 | rs = np.sort(rr) 82 | ri = np.argsort(rr) 83 | 84 | u = u.flatten(); ua = np.zeros(bins) 85 | u = u[ri] 86 | 87 | ht, bns = np.histogram(rs, bins) 88 | bn = 0.5*(bns[:-1] + bns[1:]) 89 | hm = np.cumsum(ht) 90 | 91 | ua[0] = np.mean( u[0:ht[0]] ) 92 | ua[bins-1] = np.mean( u[bins-1-ht[bins-1]:] ) 93 | for i in range(1, bins-1): 94 | ua[i] = np.mean( u[hm[i]+1:hm[i+1]]) 95 | return ua, bn 96 | 97 | 98 | 99 | def avgCorrFunc(u, bins, dim): 100 | if dim==2: 101 | Nx, Ny = np.shape(u) 102 | # xx, yy = np.meshgrid(np.arange(-Nx/2, Nx/2),np.arange(-Ny/2, Ny/2)) 103 | # rr = np.sqrt(xx*xx + yy*yy) 104 | kx = np.arange(Nx) 105 | kx, ky = np.meshgrid(kx,kx); 106 | k2 = kx*kx + ky*ky; k4=k2*k2 ; 107 | ksq= np.fft.fftshift((k2)) 108 | rr = np.sqrt(ksq) 109 | 110 | if dim==3: 111 | Nx, Ny, Nz = np.shape(u) 112 | xx, yy, zz = np.meshgrid(np.arange(Nx), np.arange(Nx), np.arange(Nx)) 113 | rr = np.sqrt(xx*xx + yy*yy + zz*zz) 114 | 115 | 116 | rr = rr.flatten() 117 | rs = np.sort(rr) 118 | ri = np.argsort(rr) 119 | 120 | u = u.flatten(); ua = np.zeros(bins) 121 | u = u[ri] 122 | 123 | ht, bns = np.histogram(rs, bins) 124 | bn = 0.5*(bns[:-1] + bns[1:]) 125 | hm = np.cumsum(ht) 126 | 127 | ua[0] = np.mean( u[0:ht[0]] ) 128 | ua[bins-1] = np.mean( u[bins-1-ht[bins-1]:] ) 129 | for i in range(1, bins-1): 130 | ua[i] = np.mean( u[hm[i]+1:hm[i+1]]) 131 | return ua, bn 132 | 133 | 134 | cpdef azimuthalAverage(u, r, bins): 135 | """ 136 | Obtains radial distribution of field 137 | 138 | Parameters 139 | ---------- 140 | u: A field variable to be averaged 141 | r: Radial vector of same shape 142 | bins: how many bins to do 143 | 144 | Returns 145 | ------- 146 | r: value of the radial component 147 | ur: the averaged field along radial direction 148 | """ 149 | 150 | rr = r.flatten() 151 | rs = np.sort(rr) 152 | ri = np.argsort(rr) 153 | 154 | u = u.flatten(); ua = np.zeros(bins) 155 | u = u[ri] 156 | 157 | ht, bns = np.histogram(rs, bins) 158 | bn = 0.5*(bns[:-1] + bns[1:]) 159 | hm = np.cumsum(ht) 160 | 161 | ua[0] = np.mean( u[0:ht[0]] ) 162 | ua[bins-1] = np.mean( u[bins-1-ht[bins-1]:] ) 163 | for i in range(1, bins-1): 164 | ua[i] = np.mean( u[hm[i]+1:hm[i+1]]) 165 | n1 = np.size(bn) 166 | return bn[1:n1-1], ua[1:n1-1] 167 | 168 | 169 | def azimuthalAverage2(u): 170 | """ 171 | Obtains radial distribution of field u 172 | 173 | Parameters 174 | ---------- 175 | u: A field defined on a grid of two-dimension 176 | 177 | Returns 178 | ------- 179 | ur: the averaged field along radial direction 180 | """ 181 | y, x = np.indices(u.shape) 182 | center = np.array([(x.max()-x.min())/2.0, (x.max()-x.min())/2.0]) 183 | r = np.hypot(x - center[0], y - center[1]) 184 | 185 | # Get sorted radii 186 | ind = np.argsort(r.flat) 187 | r_sorted = r.flat[ind] 188 | i_sorted = u.flat[ind] 189 | 190 | # Get the integer part of the radii (bin size = 1) 191 | r_int = r_sorted.astype(int) 192 | 193 | # Find all pixels that fall within each radial bin. 194 | deltar = r_int[1:] - r_int[:-1] # Assumes all radii represented 195 | rind = np.where(deltar)[0] # location of changed radius 196 | nr = rind[1:] - rind[:-1] # number of radius bin 197 | 198 | # Cumulative sum to figure out sums for each radius bin 199 | csim = np.cumsum(i_sorted, dtype=np.float64) 200 | tbin = csim[rind[1:]] - csim[rind[:-1]] 201 | 202 | ur = tbin / nr 203 | 204 | return ur 205 | 206 | 207 | def radial_profile(data, r, bins_N=100): 208 | ring_brightness, radius = np.histogram(r, weights=data, bins=bins_N) 209 | return radius[1:], ring_brightness 210 | 211 | 212 | def radial_profile2(u, r): 213 | tbin = np.bincount(r.ravel(), u.ravel()) 214 | nr = np.bincount(r.ravel()) 215 | radialprofile = tbin / nr 216 | return radialprofile, nr 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | ##------------------------------------- 226 | ## readymade bubbles and droplets 227 | ##------------------------------------- 228 | cpdef bubble(u, radi, locx=0, locy=0, phiP=1, phiM=-1): 229 | r2 = radi*radi 230 | Nx, Ny = np.shape(u) 231 | for i in range(Nx): 232 | for j in range(Ny): 233 | rsq = (i-locx)*(i-locx) + (j-locy)*(j-locy) 234 | if rsq(Nx/2-r1) and j<(Ny/2+r2) and j>(Ny/2-r2): 260 | u[i,j] = phiP 261 | else: 262 | u[i,j] = phiM 263 | return u 264 | 265 | 266 | cpdef ellipseDroplet(u, radi, eRatio=0.64, phiP=1, phiM=-1): 267 | r1, r2 = radi*eRatio, radi 268 | Nx, Ny = np.shape(u) 269 | for i in range(Nx): 270 | for j in range(Ny): 271 | rsq = (i-0.5*Nx)*(i-0.5*Nx)/(r1*r1)+(j-0.5*Ny)*(j-0.5*Ny)/(r2*r2) 272 | if rsq<0.5: 273 | u[i,j] = phiP 274 | else: 275 | u[i,j] = phiM 276 | return u 277 | 278 | 279 | cpdef twoBubbles(u, radi1, locx1, locy1, radi2, locx2, locy2, phiP=1, phiM=-1): 280 | rr1 = radi1*radi1 281 | rr2 = radi2*radi2 282 | Nx, Ny = np.shape(u) 283 | 284 | for i in range(Nx): 285 | for j in range(Ny): 286 | rsq1 = (i-locx1)*(i-locx1) + (j-locy1)*(j-locy1) 287 | rsq2 = (i-locx2)*(i-locx2) + (j-locy2)*(j-locy2) 288 | if rsq1= 1.0 or rsq == 0.0): 315 | ## v1 = 2.0*drand48()-1.0; 316 | ## v2 = 2.0*drand48()-1.0; 317 | ## rsq = v1*v1 + v2*v2; 318 | ## fac = sqrt(-2.0*log(rsq)/rsq); 319 | ## iset = 1 320 | ## return v2*fac 321 | ## else: 322 | ## iset = 0 323 | ## return v1*fac 324 | ## 325 | 326 | 327 | 328 | 329 | ## finite difference using explicit loops - differs from the implmentation in dms.pyx 330 | @cython.wraparound(False) 331 | @cython.boundscheck(False) 332 | @cython.cdivision(True) 333 | cdef class FiniteDifference: 334 | ''' 335 | Finite Difference using loops 336 | ''' 337 | cdef: 338 | readonly int Np, Nx, Ny, Nz, dim, NN 339 | readonly double h, facy, facz 340 | readonly np.ndarray iupa, jupa, idwn, jdwn 341 | 342 | 343 | def __init__(self, grid): 344 | 345 | self.dim = grid.get('dim') 346 | 347 | if self.dim == 2: 348 | self.Nx, self.Ny = grid.get('Nx'), grid.get('Ny') 349 | 350 | self.iupa = np.empty((self.Nx), dtype=DTYP1) 351 | self.jupa = np.empty((self.Ny), dtype=DTYP1) 352 | self.idwn = np.empty((self.Nx), dtype=DTYP1) 353 | self.jdwn = np.empty((self.Ny), dtype=DTYP1) 354 | 355 | for i in range(self.Nx): 356 | if i==self.Nx-1: 357 | self.iupa[i] = 0 358 | else: 359 | self.iupa[i] = i+1 360 | 361 | if i==0: 362 | self.idwn[i] = self.Nx-1 363 | else: 364 | self.idwn[i] = i-1 365 | 366 | for j in range(self.Ny): 367 | if j==self.Ny-1: 368 | self.jupa[j] = 0 369 | else: 370 | self.jupa[j] = j+1 371 | 372 | if j==0: 373 | self.jdwn[j] = self.Ny-1 374 | else: 375 | self.jdwn[j] = j-1 376 | 377 | elif self.dim == 3: 378 | self.Nx, self.Ny, self.Nz = grid.get('Nx'), grid.get('Ny'), grid.get('Nz') 379 | 380 | self.vx = np.empty(self.Nx, self.Ny, self.Nz) 381 | self.vy = np.empty(self.Nx, self.Ny, self.Nz) 382 | self.vz = np.empty(self.Nx, self.Ny, self.Nz) 383 | 384 | cpdef diffx(self, double [:,:] u): 385 | ''' 386 | computes d/dx u 387 | ''' 388 | du = np.zeros(np.shape(u), dtype=DTYPE) 389 | cdef int i, j, 390 | cdef double [:,:] du1 = du 391 | cdef int [:] iup = self.iupa 392 | cdef int [:] jup = self.jupa 393 | cdef int [:] idw = self.idwn 394 | cdef int [:] jdw = self.jdwn 395 | 396 | for i in range(self.Nx): 397 | for j in range(self.Ny): 398 | du1[i,j] = .1*(u[iup[i],jup[j]]-u[iup[i],jdw[j]]) + .3*(u[i,jup[j]]-u[i,jdw[j]]) +.1*(u[idw[i],jup[j]]-u[idw[i],jdw[j]]) 399 | return du 400 | 401 | cpdef diffy(self, double [:,:] u): 402 | ''' 403 | computes d/dy u 404 | ''' 405 | du = np.zeros(np.shape(u), dtype=DTYPE) 406 | cdef int i, j, 407 | cdef double [:,:] du1 = du 408 | cdef int [:] iup = self.iupa 409 | cdef int [:] jup = self.jupa 410 | cdef int [:] idw = self.idwn 411 | cdef int [:] jdw = self.jdwn 412 | 413 | for i in range(self.Nx): 414 | for j in range(self.Ny): 415 | du1[i,j] = .1*(u[iup[i],jup[j]]-u[idw[i],jup[j]]) + .3*(u[iup[i],j]-u[idw[i],j]) +.1*(u[iup[i],jdw[j]]-u[idw[i],jdw[j]]) 416 | return du 417 | 418 | cpdef laplacian(self, double [:,:] u): 419 | ''' 420 | computes D^2 u 421 | ''' 422 | du = np.zeros(np.shape(u), dtype=DTYPE) 423 | cdef int i, j 424 | cdef double [:,:] du1 = du 425 | cdef int [:] iup = self.iupa 426 | cdef int [:] jup = self.jupa 427 | cdef int [:] idw = self.idwn 428 | cdef int [:] jdw = self.jdwn 429 | 430 | for i in range(self.Nx): 431 | for j in range(self.Ny): 432 | du1[i,j] = -0.5*u[idw[i],jup[j]]+2.0*u[i,jup[j]]-0.5*u[iup[i],jup[j]] + 2.0*u[idw[i],j]-6.0*u[i,j]+2.0*u[iup[i],j] - 0.5*u[idw[i],jdw[j]]+2.0*u[i,jdw[j]]-0.5*u[iup[i],jdw[j]] 433 | return du 434 | 435 | cpdef diffx1(self, double [:,:] u): 436 | ''' 437 | computes d/dx u 438 | ''' 439 | du = np.zeros(np.shape(u), dtype=DTYPE) 440 | cdef int i, j, jup, jup2, jup3, jup4, jup5, jdw, jdw2, jdw3, jdw4, jdw5 441 | cdef double [:,:] du1 = du 442 | cdef int [:] iupa = self.iupa 443 | cdef int [:] jupa = self.jupa 444 | cdef int [:] idwn = self.idwn 445 | cdef int [:] jdwn = self.jdwn 446 | 447 | cdef double fp = 4.0/105, tt = 1.0/280.0 448 | 449 | for i in range(self.Nx): 450 | for j in range(self.Ny): 451 | jup = jupa[j] 452 | jup2 = jupa[jupa[j]] 453 | jup3 = jupa[jupa[jupa[j]]] 454 | jup4 = jupa[jupa[jupa[jupa[j]]]] 455 | jup5 = jupa[jupa[jupa[jupa[iupa[j]]]]] 456 | jdw = jdwn[j]; 457 | jdw2 = jdwn[jdwn[j]]; 458 | jdw3 = jdwn[jdwn[jdwn[j]]]; 459 | jdw4 = jdwn[jdwn[jdwn[jdwn[j]]]]; 460 | jdw5 = jdwn[jdwn[jdwn[jdwn[jdwn[j]]]]]; 461 | 462 | du1[i,j] = -tt*u[i,jup4]+fp*u[i,jup3]-.2*u[i,jup2]+.8*u[i,jup]+tt*u[i,jdw4]-fp*u[i,jdw3]+.2*u[i,jdw2]-.8*u[i,jdw] 463 | return du 464 | 465 | cpdef diffx2(self, double [:,:] u): 466 | ''' 467 | computes d/dx u 468 | ''' 469 | du = np.zeros(np.shape(u), dtype=DTYPE) 470 | cdef int i, j, jup, jup2, jup3, jup4, jup5, jdw, jdw2, jdw3, jdw4, jdw5 471 | cdef double [:,:] du1 = du 472 | 473 | cdef double t1 = 1.0/3, t2 = 1.0/12 474 | 475 | for i in range(self.Nx): 476 | for j in range(self.Ny): 477 | du1[i,j] = t1*(u[i,j+1]-u[i,j-1]) + t2*(u[i+1,j+1]+u[i+1,j-1]) - t2*(u[i-1,j+1]+u[i-1,j-1]) 478 | return du 479 | 480 | cpdef diffy2(self, double [:,:] u): 481 | ''' 482 | computes d/dx u 483 | ''' 484 | du = np.zeros(np.shape(u), dtype=DTYPE) 485 | cdef int i, j, jup, jup2, jup3, jup4, jup5, jdw, jdw2, jdw3, jdw4, jdw5 486 | cdef double [:,:] du1 = du 487 | 488 | cdef double t1 = 1.0/3, t2 = 1.0/12 489 | 490 | for i in range(self.Nx): 491 | for j in range(self.Ny): 492 | du1[i,j] = t1*(u[i+1,j]-u[i-1,j]) + t2*(u[i+1,j-1]+u[i+1,j+1]) - t2*(u[i-1,j-1]+u[i-1,j+1]) 493 | return du 494 | 495 | cpdef lap2(self, double [:,:] u): 496 | ''' 497 | computes d/dx u 498 | ''' 499 | du = np.zeros(np.shape(u), dtype=DTYPE) 500 | cdef int i, j, jup, jup2, jup3, jup4, jup5, jdw, jdw2, jdw3, jdw4, jdw5 501 | cdef double [:,:] du1 = du 502 | 503 | cdef double t1 = 1.0/6, t2 = 4.0/6, t3=20/6.0 504 | 505 | for i in range(self.Nx): 506 | for j in range(self.Ny): 507 | du1[i,j] = t1*(u[i-1,j-1]+u[i-1,j+1]+u[i+1,j+1]+u[i+1,j-1]) + t2*( u[i,j+1]+u[i,j-1]+u[i-1,j]+u[i+1,j] ) - t3*u[i,j] 508 | return du 509 | 510 | cpdef diffy1(self, double [:,:] u): 511 | ''' 512 | computes d/dy u 513 | ''' 514 | du = np.zeros(np.shape(u), dtype=DTYPE) 515 | cdef int i, j, iup, iup2, iup3, iup4, iup5, idw, idw2, idw3, idw4, idw5 516 | cdef double [:,:] du1 = du 517 | cdef int [:] iupa = self.iupa 518 | cdef int [:] jupa = self.jupa 519 | cdef int [:] idwn = self.idwn 520 | cdef int [:] jdwn = self.jdwn 521 | 522 | cdef double fp = 4.0/105, tt = 1.0/280.0 523 | 524 | for i in range(self.Nx): 525 | iup = iupa[i] 526 | iup2 = iupa[iupa[i]] 527 | iup3 = iupa[iupa[iupa[i]]] 528 | iup4 = iupa[iupa[iupa[iupa[i]]]] 529 | iup5 = iupa[iupa[iupa[iupa[iupa[i]]]]] 530 | idw = idwn[i]; 531 | idw2 = idwn[idwn[i]]; 532 | idw3 = idwn[idwn[idwn[i]]]; 533 | idw4 = idwn[idwn[idwn[idwn[i]]]]; 534 | idw5 = idwn[idwn[idwn[idwn[idwn[i]]]]]; 535 | for j in range(self.Ny): 536 | du1[i,j] = -tt*u[iup4,j]+fp*u[iup3,j]-.2*u[iup2,j]+.8*u[iup,j]+tt*u[idw4,j]-fp*u[idw3,j]+.2*u[idw2,j]-.8*u[idw,j] 537 | return du 538 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | numpy 2 | jupyter 3 | matplotlib 4 | cython 5 | scipy 6 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | import numpy 2 | import os, sys, re 3 | from setuptools import setup, Extension 4 | from Cython.Build import cythonize 5 | import Cython.Compiler.Options 6 | Cython.Compiler.Options.annotate=True 7 | 8 | 9 | if 'darwin'==(sys.platform).lower(): 10 | extension1 = Extension('pygl/*', ['pygl/*.pyx'], 11 | include_dirs=[numpy.get_include()], 12 | extra_compile_args=['-mmacosx-version-min=10.9'], 13 | extra_link_args=['-mmacosx-version-min=10.9'], 14 | ) 15 | else: 16 | extension1 = Extension('pygl/*', ['pygl/*.pyx'], 17 | include_dirs=[numpy.get_include()], 18 | ) 19 | 20 | 21 | 22 | 23 | with open("README.md", "r") as fh: 24 | long_description = fh.read() 25 | 26 | 27 | cwd = os.path.abspath(os.path.dirname(__file__)) 28 | with open(os.path.join(cwd, 'pygl', '__init__.py')) as fp: 29 | for line in fp: 30 | m = re.search(r'^\s*__version__\s*=\s*([\'"])([^\'"]+)\1\s*$', line) 31 | if m: 32 | version = m.group(2) 33 | break 34 | else: 35 | raise RuntimeError('Unable to find own __version__ string') 36 | 37 | 38 | setup( 39 | name='pygl', 40 | version=version, 41 | url='https://github.com/rajeshrinet/pygl', 42 | project_urls={ 43 | "Documentation": "https://pygl.readthedocs.io", 44 | "Source": "https://github.com/rajeshrinet/pygl", 45 | }, 46 | author='The pygl team', 47 | author_email = 'pygl@googlegroups.com', 48 | license='MIT', 49 | description='pygl is a numerical library for inference, forecasts,\ 50 | and optimal control of epidemiological models in Python', 51 | long_description=long_description, 52 | long_description_content_type='text/markdown', 53 | platforms='tested on Linux, macOS, and windows', 54 | ext_modules=cythonize([extension1], 55 | compiler_directives={'language_level': 3}, 56 | ), 57 | libraries=[], 58 | install_requires=['cython','numpy','scipy'], 59 | packages=['pygl'], 60 | include_package_data=True, 61 | setup_requires=['wheel'], 62 | classifiers=[ 63 | 'License :: OSI Approved :: MIT License', 64 | 'Programming Language :: Python :: 3', 65 | 'Programming Language :: Python :: 3.7', 66 | 'Topic :: Scientific/Engineering', 67 | 'Topic :: Scientific/Engineering :: Mathematics', 68 | 'Intended Audience :: Science/Research', 69 | 'Intended Audience :: Education', 70 | ], 71 | ) 72 | -------------------------------------------------------------------------------- /tests/installTests.py: -------------------------------------------------------------------------------- 1 | """ 2 | Unittesting for the pygl module. 3 | """ 4 | import sys 5 | import pystokes 6 | import unittest 7 | import inspect 8 | import numpy as np 9 | import scipy as sp 10 | 11 | 12 | 13 | if __name__ == '__main__': 14 | unittest.main() 15 | -------------------------------------------------------------------------------- /tests/testNotebooks.py: -------------------------------------------------------------------------------- 1 | import datetime, os, re, subprocess, sys, argparse, time, unittest 2 | 3 | 4 | ignoreFlag=True # change to False if not to ignore 5 | 6 | 7 | 8 | def test_notebook(path): 9 | """ 10 | Tests a notebook in a subprocess, exists if it doesn't finish. 11 | """ 12 | import nbconvert 13 | print('Running ' + path + ' ... ', end='') 14 | sys.stdout.flush() 15 | 16 | # Load notebook, convert to python 17 | e = nbconvert.exporters.PythonExporter() 18 | code, __ = e.from_filename(path) 19 | 20 | # Remove coding statement, if present 21 | ipylines = ['ipython', 'show('] 22 | code = '\n'.join([x for x in code.splitlines() if not 'ipython' in x]) 23 | for x in code.splitlines(): 24 | if not any(s in ipylines for s in x): 25 | code += '\n'.join([x]) 26 | # print(code) 27 | 28 | # Tell matplotlib not to produce any figures 29 | env = os.environ.copy() 30 | env['MPLBACKEND'] = 'Template' 31 | 32 | # Run in subprocess 33 | start = time.time() 34 | cmd = [sys.executable, '-c', code] 35 | try: 36 | p = subprocess.Popen( 37 | cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env 38 | ) 39 | stdout, stderr = p.communicate() 40 | # TODO: Use p.communicate(timeout=3600) if Python3 only 41 | if p.returncode != 0: 42 | # Show failing code, output and errors before returning 43 | print('ERROR') 44 | # print('-- script ' + '-' * (79 - 10)) 45 | # for i, line in enumerate(code.splitlines()): 46 | # j = str(1 + i) 47 | # print(j + ' ' * (5 - len(j)) + line) 48 | print('-- stdout ' + '-' * (79 - 10)) 49 | print(stdout) 50 | print('-- stderr ' + '-' * (79 - 10)) 51 | print(stderr) 52 | print('-' * 79) 53 | return False 54 | except KeyboardInterrupt: 55 | p.terminate() 56 | stop = time.time() 57 | print('ABORTED after', round(stop-start,4), "s") 58 | sys.exit(1) 59 | 60 | # Successfully run 61 | stop = time.time() 62 | print('ok. Run took ', round(stop-start,4), "s") 63 | return True 64 | 65 | 66 | def export_notebook(ipath, opath): 67 | """ 68 | Exports the notebook at `ipath` to a python file at `opath`. 69 | """ 70 | import nbconvert 71 | from traitlets.config import Config 72 | 73 | # Create nbconvert configuration to ignore text cells 74 | c = Config() 75 | c.TemplateExporter.exclude_markdown = True 76 | 77 | # Load notebook, convert to python 78 | e = nbconvert.exporters.PythonExporter(config=c) 79 | code, __ = e.from_filename(ipath) 80 | 81 | # Remove "In [1]:" comments 82 | r = re.compile(r'(\s*)# In\[([^]]*)\]:(\s)*') 83 | code = r.sub('\n\n', code) 84 | 85 | # Store as executable script file 86 | with open(opath, 'w') as f: 87 | f.write('#!/usr/bin/env python') 88 | f.write(code) 89 | os.chmod(opath, 0o775) 90 | 91 | 92 | cwd0 =os.getcwd() 93 | os.chdir('../examples/') 94 | cwd =os.getcwd() 95 | 96 | path1 = cwd+'/fourierMethod.ipynb' 97 | path2 = cwd+'/diffusionEquation.ipynb' 98 | test_notebook(path1) 99 | test_notebook(path2) 100 | --------------------------------------------------------------------------------