From 6f6d4e39bb8106716e57518aae956e6c00872a3f Mon Sep 17 00:00:00 2001 From: Nick Murphy Date: Tue, 30 Jul 2024 23:10:18 -0400 Subject: [PATCH 1/3] Add dispersion notebooks --- notebooks/dispersion_solver.ipynb | 709 +++++++++++++++++++++ notebooks/dispersion_solver_complete.ipynb | 702 ++++++++++++++++++++ 2 files changed, 1411 insertions(+) create mode 100644 notebooks/dispersion_solver.ipynb create mode 100644 notebooks/dispersion_solver_complete.ipynb diff --git a/notebooks/dispersion_solver.ipynb b/notebooks/dispersion_solver.ipynb new file mode 100644 index 0000000..082c089 --- /dev/null +++ b/notebooks/dispersion_solver.ipynb @@ -0,0 +1,709 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "awfXhUFMuSvV" + }, + "source": [ + "# **Dispersion Solvers** " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b1_oQZ4B05ZB" + }, + "source": [ + "[`plasmapy.dispersion`]: https://docs.plasmapy.org/en/stable/dispersion/index.html\n", + "\n", + "This tutorial introduces us to [`plasmapy.dispersion`], which is a collection of dispersion solvers that are integrated into PlasmaPy." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JmztSJWW05i2" + }, + "source": [ + "We will begin with some preliminary imports. To execute a cell in a Jupyter notebook, press **Shift + Enter**. If you need to restart the notebook, please execute this cell again.\n", + "\n", + "If using Google Colab, click **Run anyway** when prompted. (If prompted again, select **Restart runtime** when the installation finishes.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "Svr5Ce-opcPP", + "jupyter": { + "outputs_hidden": true + }, + "outputId": "2d3d74ed-f6f5-4cc1-e81a-25b540063517" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: astropy in /usr/local/lib/python3.10/dist-packages (6.1.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.7.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.26.4)\n", + "Requirement already satisfied: plasmapy in /usr/local/lib/python3.10/dist-packages (2024.7.0)\n", + "Requirement already satisfied: pyerfa>=2.0.1.1 in /usr/local/lib/python3.10/dist-packages (from astropy) (2.0.1.4)\n", + "Requirement already satisfied: astropy-iers-data>=0.2024.7.1.0.34.3 in /usr/local/lib/python3.10/dist-packages (from astropy) (0.2024.7.22.0.34.13)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.10/dist-packages (from astropy) (6.0.1)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.10/dist-packages (from astropy) (24.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: h5py>=3.7.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (3.11.0)\n", + "Requirement already satisfied: ipykernel>=5.5.6 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (5.5.6)\n", + "Requirement already satisfied: ipywidgets>=6.0.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (7.7.1)\n", + "Requirement already satisfied: lmfit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.3.2)\n", + "Requirement already satisfied: mpmath>=1.2.1 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.3.0)\n", + "Requirement already satisfied: numba>=0.57.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (0.60.0)\n", + "Requirement already satisfied: pandas>=1.5.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2.1.4)\n", + "Requirement already satisfied: requests>=2.28.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2.31.0)\n", + "Requirement already satisfied: scipy>=1.9.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.13.1)\n", + "Requirement already satisfied: setuptools>=61.2.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (71.0.4)\n", + "Requirement already satisfied: tqdm>=4.65.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (4.66.4)\n", + "Requirement already satisfied: voila>=0.2.7 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (0.5.7)\n", + "Requirement already satisfied: wrapt>=1.14.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.14.1)\n", + "Requirement already satisfied: xarray>=2022.6.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2024.6.0)\n", + "Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (0.2.0)\n", + "Requirement already satisfied: ipython>=5.0.0 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (7.34.0)\n", + "Requirement already satisfied: traitlets>=4.1.0 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (5.7.1)\n", + "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (7.4.9)\n", + "Requirement already satisfied: tornado>=4.2 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (6.3.3)\n", + "Requirement already satisfied: widgetsnbextension~=3.6.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=6.0.0->plasmapy) (3.6.7)\n", + "Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=6.0.0->plasmapy) (3.0.11)\n", + "Requirement already satisfied: asteval>=1.0 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (1.0.1)\n", + "Requirement already satisfied: uncertainties>=3.2.2 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (3.2.2)\n", + "Requirement already satisfied: dill>=0.3.4 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (0.3.8)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.57.0->plasmapy) (0.43.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5.0->plasmapy) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5.0->plasmapy) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (2024.7.4)\n", + "Requirement already satisfied: jupyter-core>=4.11.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (5.7.2)\n", + "Requirement already satisfied: jupyter-server<3,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (2.14.2)\n", + "Requirement already satisfied: jupyterlab-server<3,>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (2.27.3)\n", + "Requirement already satisfied: nbclient>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (0.10.0)\n", + "Requirement already satisfied: nbconvert<8,>=6.4.5 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (6.5.4)\n", + "Requirement already satisfied: websockets>=9.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (12.0)\n", + "Requirement already satisfied: jedi>=0.16 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.19.1)\n", + "Requirement already satisfied: decorator in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (4.4.2)\n", + "Requirement already satisfied: pickleshare in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.7.5)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (3.0.47)\n", + "Requirement already satisfied: pygments in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (2.16.1)\n", + "Requirement already satisfied: backcall in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.2.0)\n", + "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.1.7)\n", + "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (4.9.0)\n", + "Requirement already satisfied: entrypoints in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (0.4)\n", + "Requirement already satisfied: nest-asyncio>=1.5.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (1.6.0)\n", + "Requirement already satisfied: pyzmq>=23.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (24.0.1)\n", + "Requirement already satisfied: platformdirs>=2.5 in /usr/local/lib/python3.10/dist-packages (from jupyter-core>=4.11.0->voila>=0.2.7->plasmapy) (4.2.2)\n", + "Requirement already satisfied: anyio>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.7.1)\n", + "Requirement already satisfied: argon2-cffi>=21.1 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (23.1.0)\n", + "Requirement already satisfied: jinja2>=3.0.3 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.1.4)\n", + "Requirement already satisfied: jupyter-events>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.10.0)\n", + "Requirement already satisfied: jupyter-server-terminals>=0.4.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.5.3)\n", + "Requirement already satisfied: nbformat>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (5.10.4)\n", + "Requirement already satisfied: overrides>=5.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (7.7.0)\n", + "Requirement already satisfied: prometheus-client>=0.9 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.20.0)\n", + "Requirement already satisfied: send2trash>=1.8.2 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.8.3)\n", + "Requirement already satisfied: terminado>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.18.1)\n", + "Requirement already satisfied: websocket-client>=1.7 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.8.0)\n", + "Requirement already satisfied: babel>=2.10 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (2.15.0)\n", + "Requirement already satisfied: json5>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.9.25)\n", + "Requirement already satisfied: jsonschema>=4.18.0 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (4.23.0)\n", + "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (4.9.4)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (4.12.3)\n", + "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (6.1.0)\n", + "Requirement already satisfied: defusedxml in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.7.1)\n", + "Requirement already satisfied: jupyterlab-pygments in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (2.1.5)\n", + "Requirement already satisfied: mistune<2,>=0.8.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.8.4)\n", + "Requirement already satisfied: pandocfilters>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (1.5.1)\n", + "Requirement already satisfied: tinycss2 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: notebook>=4.4.1 in /usr/local/lib/python3.10/dist-packages (from widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (6.5.5)\n", + "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.10/dist-packages (from anyio>=3.1.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.1)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio>=3.1.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.2.2)\n", + "Requirement already satisfied: argon2-cffi-bindings in /usr/local/lib/python3.10/dist-packages (from argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (21.2.0)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jedi>=0.16->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.8.4)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.19.1)\n", + "Requirement already satisfied: python-json-logger>=2.0.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.0.7)\n", + "Requirement already satisfied: rfc3339-validator in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.1.4)\n", + "Requirement already satisfied: rfc3986-validator>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.1.1)\n", + "Requirement already satisfied: fastjsonschema>=2.15 in /usr/local/lib/python3.10/dist-packages (from nbformat>=5.3.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.20.0)\n", + "Requirement already satisfied: nbclassic>=0.4.7 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (1.1.0)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.10/dist-packages (from pexpect>4.3->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.10/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.2.13)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4->nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (2.5)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.5.1)\n", + "Requirement already satisfied: fqdn in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.5.1)\n", + "Requirement already satisfied: isoduration in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (20.11.0)\n", + "Requirement already satisfied: jsonpointer>1.13 in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.0.0)\n", + "Requirement already satisfied: uri-template in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: webcolors>=24.6.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (24.6.0)\n", + "Requirement already satisfied: notebook-shim>=0.2.3 in /usr/local/lib/python3.10/dist-packages (from nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (0.2.4)\n", + "Requirement already satisfied: cffi>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from argon2-cffi-bindings->argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.16.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.22)\n", + "Requirement already satisfied: arrow>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from isoduration->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: types-python-dateutil>=2.8.10 in /usr/local/lib/python3.10/dist-packages (from arrow>=0.15.0->isoduration->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.9.0.20240316)\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import sys\n", + "\n", + "if 'google.colab' in str(get_ipython()):\n", + " if 'plasmapy' not in sys.modules:\n", + " !pip install astropy matplotlib numpy plasmapy\n", + "\n", + "import astropy.units as u\n", + "from astropy.visualization import quantity_support\n", + "from astropy import constants\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from plasmapy.formulary import speeds\n", + "from plasmapy.particles import Particle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_j23xzmRuQ44" + }, + "source": [ + "# Background" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9YU89B651h32" + }, + "source": [ + "When dealing with plasma, it is common to find oneself using dispersion relations. A dispersion relation allows the wavelength/wavenumber to be related to the frequency.\n", + "\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K6DyAyMWMJ3v" + }, + "source": [ + "For electromagnetic waves in a vaccumn, the dispersion relation is:\n", + "\n", + "$k^{2} - \\omega^{2}c^{2} = 0 \\, ,$\n", + "\n", + "where $k$ is the wavenumber, $\\omega$ is the frequency and $c$ is the speed of light.\n", + "\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bNWO8JwALC-0" + }, + "source": [ + "When working with plasma however, the dispersion relationships tend to be more complex. To deal with these more complex relationships, PlasmaPy has implemented a number of solvers to make life a little easier." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H76qgkgcPrbC" + }, + "source": [ + "# Stix Dispersion" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6I-erN1UPAFO" + }, + "source": [ + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "Today we are going to look at one specific dispersion relation, [`Stix`], which allows us to calculate the dispersion relationship for a cold plasma. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05oPmUkbBozI" + }, + "source": [ + "\n", + "To begin, we import the stix function from the dispersion subpackage and define some input values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FTK-Zj3QprtV" + }, + "outputs": [], + "source": [ + "from plasmapy.dispersion.analytical.stix_ import stix\n", + "\n", + "inputs_1 = {}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6lCFigZCS7m8" + }, + "source": [ + "B – The magnetic field magnitude in units convertible to T.\n", + "\n", + "ω – Wavefrequency in units convertible to rad/s.\n", + "\n", + "ions – A list or single instance of particle-like objects representing the ion species.\n", + "\n", + "n_i – Ion number density in units convertible to ${\\rm m}^{-3}$.\n", + "\n", + "theta – The angle of propagation of the wave with respect to the magnetic field.\n", + "\n", + "\n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "Note: Stix is able to take a single value/array for theta or ω, so which one you choose depends on the situation." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AGER6dbMEdQ4" + }, + "source": [ + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "[`Stix`] will calculate the normal surface waves propagating through a magnetized uniform cold plasma. So next we define a meshgrid based on the number of theta values, then we compute the corresponding wavenumbers.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rlR_SL1uP1-u" + }, + "outputs": [], + "source": [ + "omegas, thetas = np.meshgrid(\n", + " inputs_1[\"w\"].value, inputs_1[\"theta\"].value, indexing=\"ij\"\n", + ")\n", + "omegas = np.dstack((omegas,) * 4).squeeze()\n", + "thetas = np.dstack((thetas,) * 4).squeeze()\n", + "\n", + "k =" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WaLhmcYeHcwB" + }, + "source": [ + "With our wavenumbers computed, we can calculate the corresponding velocities in x and z.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rlr-tDx-H4tE" + }, + "outputs": [], + "source": [ + "from astropy.constants.si import c\n", + "\n", + "u_v = {}\n", + "\n", + "mask = np.imag(k) == 0\n", + "\n", + "va_1 = speeds.va_(inputs_1[\"B\"], inputs_1[\"n_i\"], ion=inputs_1[\"ions\"])\n", + "for arr in k:\n", + " val = 0\n", + " for item in arr:\n", + " val = val + item**2\n", + " norm = (np.sqrt(val) * va_1 / inputs_1[\"w\"]).value ** 2\n", + " u_v = {\n", + " \"ux\": norm * omegas[mask] * np.sin(thetas[mask]) / (k.value[mask] * c.value),\n", + " \"uz\": norm * omegas[mask] * np.cos(thetas[mask]) / (k.value[mask] * c.value),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_KUYgOwEIRh4" + }, + "source": [ + "Let us plot the results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 749 + }, + "id": "srX4TluoIRrJ", + "outputId": "36ede82d-334e-4ebb-ea0d-132b94b34b8e" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.10/dist-packages/matplotlib/collections.py:192: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " offsets = np.asanyarray(offsets, float)\n", + "/usr/local/lib/python3.10/dist-packages/matplotlib/transforms.py:2860: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " vmin, vmax = map(float, [vmin, vmax])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fs = 14\n", + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figheight = 1.6 * figheight\n", + "fig = plt.figure(figsize=[figwidth, figheight])\n", + "\n", + "plt.scatter(\n", + " u_v[\"ux\"],\n", + " u_v[\"uz\"],\n", + ")\n", + "\n", + "plt.xlabel(r\"$u_x$\", fontsize=fs)\n", + "plt.ylabel(r\"$u_z$\", fontsize=fs)\n", + "\n", + "pad = 1.25\n", + "plt.ylim(min(u_v[\"uz\"]) * pad, max(u_v[\"uz\"]) * pad)\n", + "plt.xlim(min(u_v[\"ux\"]) * pad, max(u_v[\"ux\"]) * pad)\n", + "\n", + "plt.tick_params(\n", + " which=\"both\",\n", + " direction=\"in\",\n", + " labelsize=fs,\n", + " right=True,\n", + " length=5,\n", + ")\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6KMWDNXPU_BP" + }, + "source": [ + "Different input values will produce very different plots, try one of the following." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fOEq7DmYSRDH" + }, + "outputs": [], + "source": [ + "inputs_2 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434 * u.T,\n", + " \"w\": (37125810) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_3 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434534 * u.T,\n", + " \"w\": (2 * 10**10) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_4 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434600 * u.T,\n", + " \"w\": (54 * 10**9) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_5 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434634 * u.T,\n", + " \"w\": (58 * 10**9) * u.rad / u.s,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RizzJgthRnwl" + }, + "source": [ + "# Additional Solvers\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "plybpyVyRtJh" + }, + "source": [ + "PlasmaPy can solve dispersion relations both numerically and analytically, each type of solver is stored in its own sub directory." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mHp2z9frTCEn" + }, + "source": [ + "[`plasmapy.dispersion.analytical`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.analytical.html\n", + "\n", + "[`plasmapy.dispersion.numerical`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.numerical.html\n", + "\n", + "[`MHD`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.analytical.mhd_waves_.htm\n", + "\n", + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "[`Two Fluid`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.analytical.two_fluid_.two_fluid.html\n", + "\n", + "[`Hollweg`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.numerical.hollweg_.hollweg.html\n", + "\n", + "[`Kinetic Alfven`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.numerical.kinetic_alfven_.kinetic_alfven.html\n", + "\n", + "The current analytical solvers in [`plasmapy.dispersion.analytical`]are:\n", + "\n", + "\n", + "* [`MHD`]\n", + "* [`Stix`]\n", + "* [`Two Fluid`]\n", + "\n", + "and the current numerical solvers in [`plasmapy.dispersion.numerical`] are:\n", + "\n", + "\n", + "* [`Hollweg`]\n", + "* [`Kinetic Alfven`]\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bll2Ck7USPNn" + }, + "source": [ + "[`Dispersion Function`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/dispersion_function.html\n", + "\n", + "# Dispersion Function\n", + "\n", + "Additionally, the dispersion subpackage contains the [`Dispersion Function`], which is commonly used in plasma physics.\n", + "\n", + "The dispersion function is given as:\n", + "\n", + "$Z(\\zeta) = \\frac{1}{\\sqrt\\pi} \\int^{∞}_{-∞} \\frac{e^{-x^{2}}}{x - \\zeta} dx \\, .$\n", + "\n", + "In plasma wave theory, the plasma dispersion function appears frequently when the background medium has a Maxwellian distribution function. The argument of this function then refers to the ratio of a wave’s phase velocity to a thermal velocity.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9jtwZv-SXPQ3" + }, + "source": [ + "To begin let us import the function and make some sample data to visualize the dispersion function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rOZrTakWW8Af" + }, + "outputs": [], + "source": [ + "from plasmapy.dispersion import plasma_dispersion_func\n", + "from plasmapy.dispersion import plasma_dispersion_func_deriv\n", + "\n", + "start =\n", + "stop =\n", + "num =" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "beNmmBS9Xdt8" + }, + "source": [ + "\n", + "\n", + "We can create a plotting function to visualize our simple dispersion relation.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "ofVtcC_pXOLu", + "outputId": "75031c1b-5e6a-4aaf-e659-dbe18404c251" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.linspace(start, stop, num)\n", + "X, Y = np.meshgrid(x, x)\n", + "Z = X + 1j * Y\n", + "\n", + "def plot_complex(X, Y, Z, N=50):\n", + " fig, (real_axis, imag_axis) = plt.subplots(1, 2)\n", + " real_axis.contourf(X, Y, Z.real, N)\n", + " imag_axis.contourf(X, Y, Z.imag, N)\n", + " real_axis.set_title(\"Real values\")\n", + " imag_axis.set_title(\"Imaginary values\")\n", + " for ax in [real_axis, imag_axis]:\n", + " ax.set_xlabel(\"Real values\")\n", + " ax.set_ylabel(\"Imaginary values\")\n", + " fig.tight_layout()\n", + "\n", + "\n", + "F = plasma_dispersion_func(Z)\n", + "plot_complex(X, Y, F)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CQMeDRICUXO_" + }, + "source": [ + "We can also visualize the derivative of the dispersion function as follows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "HSxi4YHrUc0X", + "outputId": "791920ce-8dc4-4c29-c27b-6cbb88167a69" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "F = plasma_dispersion_func_deriv(Z)\n", + "plot_complex(X, Y, F)" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/dispersion_solver_complete.ipynb b/notebooks/dispersion_solver_complete.ipynb new file mode 100644 index 0000000..f85aa2e --- /dev/null +++ b/notebooks/dispersion_solver_complete.ipynb @@ -0,0 +1,702 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# **Dispersion Solvers** " + ], + "metadata": { + "id": "awfXhUFMuSvV" + } + }, + { + "cell_type": "markdown", + "source": [ + "[`plasmapy.dispersion`]: https://docs.plasmapy.org/en/stable/dispersion/index.html\n", + "\n", + "This tutorial introduces us to [`plasmapy.dispersion`], which is a collection of dispersion solvers that are integrated into PlasmaPy." + ], + "metadata": { + "id": "b1_oQZ4B05ZB" + } + }, + { + "cell_type": "markdown", + "source": [ + "We will begin with some preliminary imports. To execute a cell in a Jupyter notebook, press **Shift + Enter**. If you need to restart the notebook, please execute this cell again.\n", + "\n", + "If using Google Colab, click **Run anyway** when prompted. (If prompted again, select **Restart runtime** when the installation finishes.)" + ], + "metadata": { + "id": "JmztSJWW05i2" + } + }, + { + "cell_type": "code", + "source": [ + "%matplotlib inline\n", + "\n", + "import sys\n", + "\n", + "if 'google.colab' in str(get_ipython()):\n", + " if 'plasmapy' not in sys.modules:\n", + " !pip install astropy matplotlib numpy plasmapy\n", + "\n", + "import astropy.units as u\n", + "from astropy.visualization import quantity_support\n", + "from astropy import constants\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from plasmapy.formulary import speeds\n", + "from plasmapy.particles import Particle" + ], + "metadata": { + "id": "Svr5Ce-opcPP", + "collapsed": true, + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2d3d74ed-f6f5-4cc1-e81a-25b540063517" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: astropy in /usr/local/lib/python3.10/dist-packages (6.1.2)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.7.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.26.4)\n", + "Requirement already satisfied: plasmapy in /usr/local/lib/python3.10/dist-packages (2024.7.0)\n", + "Requirement already satisfied: pyerfa>=2.0.1.1 in /usr/local/lib/python3.10/dist-packages (from astropy) (2.0.1.4)\n", + "Requirement already satisfied: astropy-iers-data>=0.2024.7.1.0.34.3 in /usr/local/lib/python3.10/dist-packages (from astropy) (0.2024.7.22.0.34.13)\n", + "Requirement already satisfied: PyYAML>=3.13 in /usr/local/lib/python3.10/dist-packages (from astropy) (6.0.1)\n", + "Requirement already satisfied: packaging>=19.0 in /usr/local/lib/python3.10/dist-packages (from astropy) (24.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.53.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: h5py>=3.7.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (3.11.0)\n", + "Requirement already satisfied: ipykernel>=5.5.6 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (5.5.6)\n", + "Requirement already satisfied: ipywidgets>=6.0.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (7.7.1)\n", + "Requirement already satisfied: lmfit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.3.2)\n", + "Requirement already satisfied: mpmath>=1.2.1 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.3.0)\n", + "Requirement already satisfied: numba>=0.57.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (0.60.0)\n", + "Requirement already satisfied: pandas>=1.5.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2.1.4)\n", + "Requirement already satisfied: requests>=2.28.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2.31.0)\n", + "Requirement already satisfied: scipy>=1.9.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.13.1)\n", + "Requirement already satisfied: setuptools>=61.2.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (71.0.4)\n", + "Requirement already satisfied: tqdm>=4.65.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (4.66.4)\n", + "Requirement already satisfied: voila>=0.2.7 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (0.5.7)\n", + "Requirement already satisfied: wrapt>=1.14.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (1.14.1)\n", + "Requirement already satisfied: xarray>=2022.6.0 in /usr/local/lib/python3.10/dist-packages (from plasmapy) (2024.6.0)\n", + "Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (0.2.0)\n", + "Requirement already satisfied: ipython>=5.0.0 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (7.34.0)\n", + "Requirement already satisfied: traitlets>=4.1.0 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (5.7.1)\n", + "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (7.4.9)\n", + "Requirement already satisfied: tornado>=4.2 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=5.5.6->plasmapy) (6.3.3)\n", + "Requirement already satisfied: widgetsnbextension~=3.6.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=6.0.0->plasmapy) (3.6.7)\n", + "Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=6.0.0->plasmapy) (3.0.11)\n", + "Requirement already satisfied: asteval>=1.0 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (1.0.1)\n", + "Requirement already satisfied: uncertainties>=3.2.2 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (3.2.2)\n", + "Requirement already satisfied: dill>=0.3.4 in /usr/local/lib/python3.10/dist-packages (from lmfit>=1.1.0->plasmapy) (0.3.8)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.57.0->plasmapy) (0.43.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5.0->plasmapy) (2024.1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.5.0->plasmapy) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.28.0->plasmapy) (2024.7.4)\n", + "Requirement already satisfied: jupyter-core>=4.11.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (5.7.2)\n", + "Requirement already satisfied: jupyter-server<3,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (2.14.2)\n", + "Requirement already satisfied: jupyterlab-server<3,>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (2.27.3)\n", + "Requirement already satisfied: nbclient>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (0.10.0)\n", + "Requirement already satisfied: nbconvert<8,>=6.4.5 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (6.5.4)\n", + "Requirement already satisfied: websockets>=9.0 in /usr/local/lib/python3.10/dist-packages (from voila>=0.2.7->plasmapy) (12.0)\n", + "Requirement already satisfied: jedi>=0.16 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.19.1)\n", + "Requirement already satisfied: decorator in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (4.4.2)\n", + "Requirement already satisfied: pickleshare in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.7.5)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (3.0.47)\n", + "Requirement already satisfied: pygments in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (2.16.1)\n", + "Requirement already satisfied: backcall in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.2.0)\n", + "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.1.7)\n", + "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (4.9.0)\n", + "Requirement already satisfied: entrypoints in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (0.4)\n", + "Requirement already satisfied: nest-asyncio>=1.5.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (1.6.0)\n", + "Requirement already satisfied: pyzmq>=23.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-client->ipykernel>=5.5.6->plasmapy) (24.0.1)\n", + "Requirement already satisfied: platformdirs>=2.5 in /usr/local/lib/python3.10/dist-packages (from jupyter-core>=4.11.0->voila>=0.2.7->plasmapy) (4.2.2)\n", + "Requirement already satisfied: anyio>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.7.1)\n", + "Requirement already satisfied: argon2-cffi>=21.1 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (23.1.0)\n", + "Requirement already satisfied: jinja2>=3.0.3 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.1.4)\n", + "Requirement already satisfied: jupyter-events>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.10.0)\n", + "Requirement already satisfied: jupyter-server-terminals>=0.4.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.5.3)\n", + "Requirement already satisfied: nbformat>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (5.10.4)\n", + "Requirement already satisfied: overrides>=5.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (7.7.0)\n", + "Requirement already satisfied: prometheus-client>=0.9 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.20.0)\n", + "Requirement already satisfied: send2trash>=1.8.2 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.8.3)\n", + "Requirement already satisfied: terminado>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.18.1)\n", + "Requirement already satisfied: websocket-client>=1.7 in /usr/local/lib/python3.10/dist-packages (from jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.8.0)\n", + "Requirement already satisfied: babel>=2.10 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (2.15.0)\n", + "Requirement already satisfied: json5>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.9.25)\n", + "Requirement already satisfied: jsonschema>=4.18.0 in /usr/local/lib/python3.10/dist-packages (from jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (4.23.0)\n", + "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (4.9.4)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (4.12.3)\n", + "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (6.1.0)\n", + "Requirement already satisfied: defusedxml in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.7.1)\n", + "Requirement already satisfied: jupyterlab-pygments in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (2.1.5)\n", + "Requirement already satisfied: mistune<2,>=0.8.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.8.4)\n", + "Requirement already satisfied: pandocfilters>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (1.5.1)\n", + "Requirement already satisfied: tinycss2 in /usr/local/lib/python3.10/dist-packages (from nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: notebook>=4.4.1 in /usr/local/lib/python3.10/dist-packages (from widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (6.5.5)\n", + "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.10/dist-packages (from anyio>=3.1.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.1)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio>=3.1.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.2.2)\n", + "Requirement already satisfied: argon2-cffi-bindings in /usr/local/lib/python3.10/dist-packages (from argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (21.2.0)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jedi>=0.16->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.8.4)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=4.18.0->jupyterlab-server<3,>=2.3.0->voila>=0.2.7->plasmapy) (0.19.1)\n", + "Requirement already satisfied: python-json-logger>=2.0.4 in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.0.7)\n", + "Requirement already satisfied: rfc3339-validator in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.1.4)\n", + "Requirement already satisfied: rfc3986-validator>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (0.1.1)\n", + "Requirement already satisfied: fastjsonschema>=2.15 in /usr/local/lib/python3.10/dist-packages (from nbformat>=5.3.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.20.0)\n", + "Requirement already satisfied: nbclassic>=0.4.7 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (1.1.0)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.10/dist-packages (from pexpect>4.3->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.10/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=5.0.0->ipykernel>=5.5.6->plasmapy) (0.2.13)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4->nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (2.5)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->nbconvert<8,>=6.4.5->voila>=0.2.7->plasmapy) (0.5.1)\n", + "Requirement already satisfied: fqdn in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.5.1)\n", + "Requirement already satisfied: isoduration in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (20.11.0)\n", + "Requirement already satisfied: jsonpointer>1.13 in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (3.0.0)\n", + "Requirement already satisfied: uri-template in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: webcolors>=24.6.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (24.6.0)\n", + "Requirement already satisfied: notebook-shim>=0.2.3 in /usr/local/lib/python3.10/dist-packages (from nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=6.0.0->plasmapy) (0.2.4)\n", + "Requirement already satisfied: cffi>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from argon2-cffi-bindings->argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.16.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi>=21.1->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.22)\n", + "Requirement already satisfied: arrow>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from isoduration->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (1.3.0)\n", + "Requirement already satisfied: types-python-dateutil>=2.8.10 in /usr/local/lib/python3.10/dist-packages (from arrow>=0.15.0->isoduration->jsonschema[format-nongpl]>=4.18.0->jupyter-events>=0.9.0->jupyter-server<3,>=2.0.0->voila>=0.2.7->plasmapy) (2.9.0.20240316)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Background" + ], + "metadata": { + "id": "_j23xzmRuQ44" + } + }, + { + "cell_type": "markdown", + "source": [ + "When dealing with plasma, it is common to find oneself using dispersion relations. A dispersion relation allows the wavelength/wavenumber to be related to the frequency.\n", + "\n", + "\n", + "---\n", + "\n" + ], + "metadata": { + "id": "9YU89B651h32" + } + }, + { + "cell_type": "markdown", + "source": [ + "For electromagnetic waves in a vaccumn, the dispersion relation is:\n", + "\n", + "$k^{2} - \\omega^{2}c^{2} = 0 \\, ,$\n", + "\n", + "where $k$ is the wavenumber, $\\omega$ is the frequency and $c$ is the speed of light.\n", + "\n", + "\n", + "---\n", + "\n" + ], + "metadata": { + "id": "K6DyAyMWMJ3v" + } + }, + { + "cell_type": "markdown", + "source": [ + "When working with plasma however, the dispersion relationships tend to be more complex. To deal with these more complex relationships, PlasmaPy has implemented a number of solvers to make life a little easier." + ], + "metadata": { + "id": "bNWO8JwALC-0" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Stix Dispersion" + ], + "metadata": { + "id": "H76qgkgcPrbC" + } + }, + { + "cell_type": "markdown", + "source": [ + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "Today we are going to look at one specific dispersion relation, [`Stix`], which allows us to calculate the dispersion relationship for a cold plasma. " + ], + "metadata": { + "id": "6I-erN1UPAFO" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "To begin, we import the stix function from the dispersion subpackage and define some input values." + ], + "metadata": { + "id": "05oPmUkbBozI" + } + }, + { + "cell_type": "code", + "source": [ + "from plasmapy.dispersion.analytical.stix_ import stix\n", + "\n", + "inputs_1 = {\n", + " \"theta\": np.linspace(0, np.pi, 50) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.43463483142776164 * u.T,\n", + " \"w\": 41632.94534008216 * u.rad / u.s,\n", + "}" + ], + "metadata": { + "id": "FTK-Zj3QprtV" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "B – The magnetic field magnitude in units convertible to T.\n", + "\n", + "ω – Wavefrequency in units convertible to rad/s.\n", + "\n", + "ions – A list or single instance of particle-like objects representing the ion species.\n", + "\n", + "n_i – Ion number density in units convertible to ${\\rm m}^{-3}$.\n", + "\n", + "theta – The angle of propagation of the wave with respect to the magnetic field.\n", + "\n", + "\n", + "\n", + "---\n", + "\n", + "\n", + "\n", + "Note: Stix is able to take a single value/array for theta or ω, so which one you choose depends on the situation." + ], + "metadata": { + "id": "6lCFigZCS7m8" + } + }, + { + "cell_type": "markdown", + "source": [ + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "[`Stix`] will calculate the normal surface waves propagating through a magnetized uniform cold plasma. So next we define a meshgrid based on the number of theta values, then we compute the corresponding wavenumbers.\n" + ], + "metadata": { + "id": "AGER6dbMEdQ4" + } + }, + { + "cell_type": "code", + "source": [ + "omegas, thetas = np.meshgrid(\n", + " inputs_1[\"w\"].value, inputs_1[\"theta\"].value, indexing=\"ij\"\n", + ")\n", + "omegas = np.dstack((omegas,) * 4).squeeze()\n", + "thetas = np.dstack((thetas,) * 4).squeeze()\n", + "\n", + "k = stix(**inputs_1)" + ], + "metadata": { + "id": "rlR_SL1uP1-u" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "With our wavenumbers computed, we can calculate the corresponding velocities in x and z.\n", + "\n" + ], + "metadata": { + "id": "WaLhmcYeHcwB" + } + }, + { + "cell_type": "code", + "source": [ + "from astropy.constants.si import c\n", + "\n", + "u_v = {}\n", + "\n", + "mask = np.imag(k) == 0\n", + "\n", + "va_1 = speeds.va_(inputs_1[\"B\"], inputs_1[\"n_i\"], ion=inputs_1[\"ions\"])\n", + "for arr in k:\n", + " val = 0\n", + " for item in arr:\n", + " val = val + item**2\n", + " norm = (np.sqrt(val) * va_1 / inputs_1[\"w\"]).value ** 2\n", + " u_v = {\n", + " \"ux\": norm * omegas[mask] * np.sin(thetas[mask]) / (k.value[mask] * c.value),\n", + " \"uz\": norm * omegas[mask] * np.cos(thetas[mask]) / (k.value[mask] * c.value),\n", + " }" + ], + "metadata": { + "id": "rlr-tDx-H4tE" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let us plot the results" + ], + "metadata": { + "id": "_KUYgOwEIRh4" + } + }, + { + "cell_type": "code", + "source": [ + "fs = 14\n", + "figwidth, figheight = plt.rcParams[\"figure.figsize\"]\n", + "figheight = 1.6 * figheight\n", + "fig = plt.figure(figsize=[figwidth, figheight])\n", + "\n", + "plt.scatter(\n", + " u_v[\"ux\"],\n", + " u_v[\"uz\"],\n", + ")\n", + "\n", + "plt.xlabel(r\"$u_x$\", fontsize=fs)\n", + "plt.ylabel(r\"$u_z$\", fontsize=fs)\n", + "\n", + "pad = 1.25\n", + "plt.ylim(min(u_v[\"uz\"]) * pad, max(u_v[\"uz\"]) * pad)\n", + "plt.xlim(min(u_v[\"ux\"]) * pad, max(u_v[\"ux\"]) * pad)\n", + "\n", + "plt.tick_params(\n", + " which=\"both\",\n", + " direction=\"in\",\n", + " labelsize=fs,\n", + " right=True,\n", + " length=5,\n", + ")\n", + "\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 749 + }, + "id": "srX4TluoIRrJ", + "outputId": "36ede82d-334e-4ebb-ea0d-132b94b34b8e" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/matplotlib/collections.py:192: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " offsets = np.asanyarray(offsets, float)\n", + "/usr/local/lib/python3.10/dist-packages/matplotlib/transforms.py:2860: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " vmin, vmax = map(float, [vmin, vmax])\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Different input values will produce very different plots, try one of the following." + ], + "metadata": { + "id": "6KMWDNXPU_BP" + } + }, + { + "cell_type": "code", + "source": [ + "inputs_2 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434 * u.T,\n", + " \"w\": (37125810) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_3 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434534 * u.T,\n", + " \"w\": (2 * 10**10) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_4 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434600 * u.T,\n", + " \"w\": (54 * 10**9) * u.rad / u.s,\n", + "}\n", + "\n", + "inputs_5 = {\n", + " \"theta\": np.linspace(0, np.pi, 100) * u.rad,\n", + " \"ions\": Particle(\"p\"),\n", + " \"n_i\": 1e12 * u.cm**-3,\n", + " \"B\": 0.434634 * u.T,\n", + " \"w\": (58 * 10**9) * u.rad / u.s,\n", + "}" + ], + "metadata": { + "id": "fOEq7DmYSRDH" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Additional Solvers\n" + ], + "metadata": { + "id": "RizzJgthRnwl" + } + }, + { + "cell_type": "markdown", + "source": [ + "PlasmaPy can solve dispersion relations both numerically and analytically, each type of solver is stored in its own sub directory." + ], + "metadata": { + "id": "plybpyVyRtJh" + } + }, + { + "cell_type": "markdown", + "source": [ + "[`plasmapy.dispersion.analytical`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.analytical.html\n", + "\n", + "[`plasmapy.dispersion.numerical`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.numerical.html\n", + "\n", + "[`MHD`]: https://docs.plasmapy.org/en/stable/api_static/plasmapy.dispersion.analytical.mhd_waves_.htm\n", + "\n", + "[`Stix`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/stix_dispersion.html\n", + "\n", + "[`Two Fluid`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.analytical.two_fluid_.two_fluid.html\n", + "\n", + "[`Hollweg`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.numerical.hollweg_.hollweg.html\n", + "\n", + "[`Kinetic Alfven`]: https://docs.plasmapy.org/en/stable/api/plasmapy.dispersion.numerical.kinetic_alfven_.kinetic_alfven.html\n", + "\n", + "The current analytical solvers in [`plasmapy.dispersion.analytical`]are:\n", + "\n", + "\n", + "* [`MHD`]\n", + "* [`Stix`]\n", + "* [`Two Fluid`]\n", + "\n", + "and the current numerical solvers in [`plasmapy.dispersion.numerical`] are:\n", + "\n", + "\n", + "* [`Hollweg`]\n", + "* [`Kinetic Alfven`]\n", + "\n", + "\n" + ], + "metadata": { + "id": "mHp2z9frTCEn" + } + }, + { + "cell_type": "markdown", + "source": [ + "[`Dispersion Function`]: https://docs.plasmapy.org/en/stable/notebooks/dispersion/dispersion_function.html\n", + "\n", + "# Dispersion Function\n", + "\n", + "Additionally, the dispersion subpackage contains the [`Dispersion Function`], which is commonly used in plasma physics.\n", + "\n", + "The dispersion function is given as:\n", + "\n", + "$Z(\\zeta) = \\frac{1}{\\sqrt\\pi} \\int^{∞}_{-∞} \\frac{e^{-x^{2}}}{x - \\zeta} dx \\, .$\n", + "\n", + "In plasma wave theory, the plasma dispersion function appears frequently when the background medium has a Maxwellian distribution function. The argument of this function then refers to the ratio of a wave’s phase velocity to a thermal velocity.\n" + ], + "metadata": { + "id": "Bll2Ck7USPNn" + } + }, + { + "cell_type": "markdown", + "source": [ + "To begin let us import the function and make some sample data to visualize the dispersion function." + ], + "metadata": { + "id": "9jtwZv-SXPQ3" + } + }, + { + "cell_type": "code", + "source": [ + "from plasmapy.dispersion import plasma_dispersion_func\n", + "from plasmapy.dispersion import plasma_dispersion_func_deriv\n", + "\n", + "start = -1.5\n", + "stop = 1.5\n", + "num = 100" + ], + "metadata": { + "id": "rOZrTakWW8Af" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "\n", + "We can create a plotting function to visualize our simple dispersion relation.\n", + "\n", + "\n" + ], + "metadata": { + "id": "beNmmBS9Xdt8" + } + }, + { + "cell_type": "code", + "source": [ + "x = np.linspace(start, stop, num)\n", + "X, Y = np.meshgrid(x, x)\n", + "Z = X + 1j * Y\n", + "\n", + "def plot_complex(X, Y, Z, N=50):\n", + " fig, (real_axis, imag_axis) = plt.subplots(1, 2)\n", + " real_axis.contourf(X, Y, Z.real, N)\n", + " imag_axis.contourf(X, Y, Z.imag, N)\n", + " real_axis.set_title(\"Real values\")\n", + " imag_axis.set_title(\"Imaginary values\")\n", + " for ax in [real_axis, imag_axis]:\n", + " ax.set_xlabel(\"Real values\")\n", + " ax.set_ylabel(\"Imaginary values\")\n", + " fig.tight_layout()\n", + "\n", + "\n", + "F = plasma_dispersion_func(Z)\n", + "plot_complex(X, Y, F)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "ofVtcC_pXOLu", + "outputId": "75031c1b-5e6a-4aaf-e659-dbe18404c251" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can also visualize the derivative of the dispersion function as follows." + ], + "metadata": { + "id": "CQMeDRICUXO_" + } + }, + { + "cell_type": "code", + "source": [ + "F = plasma_dispersion_func_deriv(Z)\n", + "plot_complex(X, Y, F)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "HSxi4YHrUc0X", + "outputId": "791920ce-8dc4-4c29-c27b-6cbb88167a69" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} From eea7982c6ee9c8f642f5857a3017bbfb5ff42cd7 Mon Sep 17 00:00:00 2001 From: Nick Murphy Date: Tue, 30 Jul 2024 23:19:46 -0400 Subject: [PATCH 2/3] Ignore a notebook in pre-commit --- .pre-commit-config.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index caf5493..2f5c933 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -47,6 +47,7 @@ repos: hooks: - id: nbqa-check-ast name: validate Python notebooks + exclude: notebooks/dispersion_solver.ipynb - id: nbqa-ruff name: ruff for notebooks (see https://docs.astral.sh/ruff/rules) args: [--fix, '--select=E,F,UP', '--ignore=E402,E501,E741,F401,F403,F405,F821'] From b64747e147caacf4bf27f7965433f86a30e4fd0b Mon Sep 17 00:00:00 2001 From: Nick Murphy Date: Tue, 30 Jul 2024 23:22:44 -0400 Subject: [PATCH 3/3] Add Colab link to dispersion notebook --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 7d31d64..303b899 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,8 @@ Here are links to use the notebooks. - [Astropy Units](https://colab.research.google.com/github/PlasmaPy/plasmapy-summer-school/blob/main/notebooks/astropy-units.ipynb) - [PlasmaPy Particles and Formulary](https://colab.research.google.com/github/PlasmaPy/plasmapy-summer-school/blob/main/notebooks/particles-formulary.ipynb) - - [New notebook](https://colab.research.google.com/github/PlasmaPy/plasmapy-summer-school/blob/main/notebooks/particles-formulary.ipynb) + - [Dispersion](https://colab.research.google.com/github/PlasmaPy/plasmapy-summer-school/blob/main/notebooks/dispersion_solver.ipynb) + - [New notebook](https://colab.research.google.com/github/PlasmaPy/plasmapy-summer-school/blob/main/notebooks/new.ipynb) ## Tips