diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml index e312508..d12d130 100644 --- a/.github/workflows/python-publish.yml +++ b/.github/workflows/python-publish.yml @@ -152,4 +152,14 @@ jobs: run: | for pkg in dist/*/*.tar.bz2; do conda run -n base anaconda upload "$pkg" --force - done \ No newline at end of file + done + - name: Create GitHub Release + uses: actions/create-release@v1 + with: + tag_name: "v${{ env.VERSION }}" + release_name: "v${{ env.VERSION }}" + body: "Automated release for version ${{ env.VERSION }}" + draft: false + prerelease: false + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/AUTHORS.rst b/AUTHORS.rst index 21444a1..baf258f 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -15,5 +15,5 @@ Contributions * Edward Villegas Pulgarin (`@cosmoscalibur`) * Guillaume Huet (`@guillaumehuet`) * Marc Gehring (`mg494`) - +* Kevin Sepúlveda-García (`@kssgarcia`) diff --git a/CITATION.cff b/CITATION.cff index 955e21a..58426a6 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -2,7 +2,7 @@ # Visit https://bit.ly/cffinit to generate yours today! cff-version: 1.1.0 -title: 'SolidsPy: 2D-Finite Element Analysis with Python' +title: 'SolidsPy: 2D/3D-Finite Element Analysis with Python' message: >- If you use this software, please cite it using the metadata from this file. @@ -23,7 +23,7 @@ identifiers: url: 'https://github.com/AppliedMechanics-EAFIT/SolidsPy' abstract: >- SolidsPy is a simple finite element analysis code - for 2D elasticity problems. The code uses as input + for 2D/3D elasticity problems. The code uses as input simple-to-create text files defining a model in terms of nodal, element, material, and load data. keywords: diff --git a/HISTORY.rst b/HISTORY.rst index 1d01e88..277f998 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -1,36 +1,44 @@ History ------- +2.0.0 (2025-01-01) +~~~~~~~~~~~~~~~~~~~~ + +* Fix compatibility with Python 3.11, 3.12 and 3.13 +* Update meshio version to 5.3.5 +* Add 3D elements +* Add 3D visualization using pyvista + 1.1.0 (2023-11-03) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~ * Remove NumPy types in the code that were removed since NumPy 1.24 1.0.15 (2018-05-09) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~ * Fix element ordering in `rectgrid` and doctests. 1.0.14 (2018-05-08) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~ * Add Jacobian checks. * Pytest catch exceptions. 1.0.13 (2018-05-07) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~ * Update meshio syntax for physical groups. * Add citation information to package. 1.0.12 (2018-04-16) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~~ * Documentation built with Sphinx. * Docs in ReadTheDocs. 1.0.0 (2017-07-17) -~~~~~~~~~~~~~~~~~~ +~~~~~~~~~~~~~~~~~~~ * First release on PyPI. diff --git a/LICENSE b/LICENSE index 96b53ed..fc9285b 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2015 - 2018 Juan Gomez and Nicolás Guarín-Zapata +Copyright (c) 2015 - 2025 Juan Gomez and Nicolás Guarín-Zapata Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the diff --git a/README.md b/README.md index a76df3e..5017645 100644 --- a/README.md +++ b/README.md @@ -1,109 +1,103 @@ -# SolidsPy: 2D-Finite Element Analysis with Python +# SolidsPy: 2D/3D-Finite Element Analysis with Python -![](https://raw.githubusercontent.com/AppliedMechanics-EAFIT/SolidsPy/master/docs/img/wrench.png) -[![PyPI download](https://img.shields.io/pypi/v/solidspy.svg)](https://pypi.python.org/pypi/continuum_mechanics) +![Wrench under bending](https://raw.githubusercontent.com/AppliedMechanics-EAFIT/SolidsPy/master/docs/img/wrench.png) + +[![PyPI version](https://img.shields.io/pypi/v/solidspy.svg)](https://pypi.python.org/pypi/continuum_mechanics) [![Documentation Status](https://readthedocs.org/projects/solidspy/badge/?version=latest)](https://solidspy.readthedocs.io/en/latest/) [![Downloads frequency](https://img.shields.io/pypi/dm/solidspy)](https://pypistats.org/packages/solidspy) -[![image](https://zenodo.org/badge/48294591.svg)](https://zenodo.org/badge/latestdoi/48294591) +[![DOI](https://zenodo.org/badge/48294591.svg)](https://zenodo.org/badge/latestdoi/48294591) -A simple finite element analysis code for 2D elasticity problems. The code uses -as input simple-to-create text files defining a model in terms of nodal, -element, material and load data. +A simple finite element analysis code for 2D/3D elasticity problems, written in Python. The code uses easily created text files defining a model in terms of nodal, element, material, and load data. -- Documentation: -- GitHub: -- PyPI: -- Free and open source software: [MIT license](http://en.wikipedia.org/wiki/MIT_License) +- **Documentation**: http://solidspy.readthedocs.io +- **GitHub**: https://github.com/AppliedMechanics-EAFIT/SolidsPy +- **PyPI**: https://pypi.org/project/solidspy/ +- **License**: [MIT license](http://en.wikipedia.org/wiki/MIT_License) +- **Year**: 2025 ## Features -- It is based on an open-source environment. -- It is easy to use. -- The code allows to find displacement, strain and stress solutions - for arbitrary two-dimensional domains discretized into finite - elements and subject to point loads. -- The code is organized in independent modules for pre-processing, - assembly and post-processing allowing the user to easily modify it - or add features like new elements or analyses pipelines. -- It was created with academic and research purposes. -- It has been used to tech the following courses: - - Introduction to Solid Mechanics. - - Computational Modeling. - - Introduction to the Finite Element Methods. - - Introduction to Soil Mechanics. +* **Open-Source Environment**: Entirely written in Python, leveraging popular libraries like NumPy and SciPy. -## Installation +* **Easy to Use**: Simple text input files; minimal overhead to set up new simulations. + +* **2D/3D Elasticity**: Solve displacement, strain, and stress for arbitrary 2D/3D domains using finite elements. + +* **Modular Code**: Independent modules for pre-processing, assembly, and post-processing. Extend or modify as needed. + +* **Academic & Research**: Ideal for teaching courses such as: + - Computational Modeling + - Introduction to the Finite Element Methods + + and for rapid prototyping of new FEM elements. -The code is written in Python and it depends on `numpy`, and `scipy` and. It -has been tested under Windows, Mac, Linux and Android. +* **Wide Compatibility**: Tested under Windows, macOS, Linux, and even Android (via Termux). -To install *SolidsPy* open a terminal and type: +## Installation - pip install solidspy +SolidsPy runs on Python 3.11+ and depends on numpy and scipy. -To specify through a GUI the folder where the input files are stored you will -need to install [easygui](http://easygui.readthedocs.org/en/master/). +Install via PyPI: +```bash +pip install solidspy +``` -To easily generate the required SolidsPy text files out of a -[Gmsh](http://gmsh.info/) model you will need [meshio](https://github.com/nschloe/meshio). +For a GUI file selector, install: +```bash +pip install easygui +``` -These two can be installed with: +To convert Gmsh models ([gmsh.info](http://gmsh.info/)) to SolidsPy input files, install: +```bash +pip install meshio +``` - pip install easygui - pip install meshio +Install via Conda: +```bash +conda install solidspy +``` ## How to run a simple model For further explanation check the [docs](http://solidspy.readthedocs.io/en/latest/). -Let's suppose that we have a simple model represented by the following files -(see [tutorials/square example](http://solidspy.readthedocs.io/en/latest/tutorials/square_example.html) -for further explanation). - -- `nodes.txt` +Let's suppose that we have a simple model represented by the following files (see [tutorials/square example](http://solidspy.readthedocs.io/en/latest/tutorials/square_example.html) for further explanation). +- nodes.txt ``` - 0 0.00 0.00 0 -1 - 1 2.00 0.00 0 -1 - 2 2.00 2.00 0 0 - 3 0.00 2.00 0 0 - 4 1.00 0.00 -1 -1 - 5 2.00 1.00 0 0 - 6 1.00 2.00 0 0 - 7 0.00 1.00 0 0 - 8 1.00 1.00 0 0 +0 0.00 0.00 0 -1 +1 2.00 0.00 0 -1 +2 2.00 2.00 0 0 +3 0.00 2.00 0 0 +4 1.00 0.00 -1 -1 +5 2.00 1.00 0 0 +6 1.00 2.00 0 0 +7 0.00 1.00 0 0 +8 1.00 1.00 0 0 ``` - -- `eles.txt` - +- eles.txt ``` - 0 1 0 0 4 8 7 - 1 1 0 4 1 5 8 - 2 1 0 7 8 6 3 - 3 1 0 8 5 2 6 +0 1 0 0 4 8 7 +1 1 0 4 1 5 8 +2 1 0 7 8 6 3 +3 1 0 8 5 2 6 ``` - -- `mater.txt` - +- mater.txt ``` - 1.0 0.3 +1.0 0.3 ``` - -- `loads.txt` - +- loads.txt ``` - 3 0.0 1.0 - 6 0.0 2.0 - 2 0.0 1.0 +3 0.0 1.0 +6 0.0 2.0 +2 0.0 1.0 ``` - Run it in Python as follows: - -``` python +```python import matplotlib.pyplot as plt # load matplotlib from solidspy import solids_GUI # import our package disp = solids_GUI() # run the Finite Element Analysis @@ -114,29 +108,28 @@ For Mac users it is suggested to use an IPython console to run the example. ## License -This project is licensed under the [MIT license](http://en.wikipedia.org/wiki/MIT_License). -The documents are licensed under [Creative Commons Attribution License](http://creativecommons.org/licenses/by/4.0/). +This project is licensed under the [MIT license](http://en.wikipedia.org/wiki/MIT_License). The documents are licensed under [Creative Commons Attribution License](http://creativecommons.org/licenses/by/4.0/). ## Citation -To cite SolidsPy in publications use +To cite SolidsPy in publications use: -> Nicolás Guarín-Zapata, Juan Gomez (2023). SolidsPy: Version 1.1.0 -> (Version v1.1.0). Zenodo. +> Nicolás Guarín-Zapata, Juan Gomez (2025). SolidsPy: Version 2.0.0 (Version v2.0.0). Zenodo. http://doi.org/10.5281/zenodo.4029270 -A BibTeX entry for LaTeX users is +A BibTeX entry for LaTeX users is: ```bibtex @software{solidspy, - title = {SolidsPy: 2D-Finite Element Analysis with Python}, - version = {1.1.0}, + title = {SolidsPy: 2D/3D-Finite Element Analysis with Python}, + version = {2.0.0}, author = {Guarín-Zapata, Nicolás and Gómez, Juan}, - year = 2023, + year = 2020, keywords = {Python, Finite elements, Scientific computing, Computational mechanics}, - abstract = {SolidsPy is a simple finite element analysis code for 2D elasticity - problems. The code uses as input simple-to-create text files defining a model - in terms of nodal, element, material and load data.}, + abstract = {SolidsPy is a simple finite element analysis code for + 2D/3D elasticity problems. The code uses as input simple-to-create text + files defining a model in terms of nodal, element, material and + load data.}, url = {https://github.com/AppliedMechanics-EAFIT/SolidsPy}, - doi = {https://doi.org/10.5281/zenodo.7694030} + doi = {http://doi.org/10.5281/zenodo.4029270} } -``` +``` \ No newline at end of file diff --git a/README.rst b/README.rst index accf1f5..2256e95 100644 --- a/README.rst +++ b/README.rst @@ -1,5 +1,5 @@ -SolidsPy: 2D-Finite Element Analysis with Python -================================================ +SolidsPy: 2D/3D-Finite Element Analysis with Python +==================================================== .. figure:: https://raw.githubusercontent.com/AppliedMechanics-EAFIT/SolidsPy/master/docs/img/wrench.png :alt: Wrench under bending @@ -20,66 +20,70 @@ SolidsPy: 2D-Finite Element Analysis with Python :target: https://zenodo.org/badge/latestdoi/48294591 -A simple finite element analysis code for 2D elasticity problems. -The code uses as input simple-to-create text files -defining a model in terms of nodal, element, material and load data. - -- Documentation: http://solidspy.readthedocs.io -- GitHub: https://github.com/AppliedMechanics-EAFIT/SolidsPy -- PyPI: https://pypi.org/project/solidspy/ -- Free and open source software: `MIT license `__ - +A simple finite element analysis code for 2D/3D elasticity problems, written in Python. +The code uses easily created text files defining a model in terms of nodal, element, +material, and load data. +- **Documentation**: http://solidspy.readthedocs.io +- **GitHub**: https://github.com/AppliedMechanics-EAFIT/SolidsPy +- **PyPI**: https://pypi.org/project/solidspy/ +- **License**: `MIT license `__ +- **Year**: 2025 Features -------- -* It is based on an open-source environment. - -* It is easy to use. +* **Open-Source Environment** + Entirely written in Python, leveraging popular libraries like NumPy and SciPy. -* The code allows to find displacement, strain and stress solutions for - arbitrary two-dimensional domains discretized into finite elements and - subject to point loads. +* **Easy to Use** + Simple text input files; minimal overhead to set up new simulations. -* The code is organized in independent modules for pre-processing, assembly and - post-processing allowing the user to easily modify it or add features like - new elements or analyses pipelines. +* **2D/3D Elasticity** + Solve displacement, strain, and stress for arbitrary 2D/3D domains using finite elements. -* It was created with academic and research purposes. +* **Modular Code** + Independent modules for pre-processing, assembly, and post-processing. Extend or modify as needed. -* It has been used to tech the following courses: - - - Computational Modeling. - - Introduction to the Finite Element Methods. +* **Academic & Research** + Ideal for teaching courses such as: + + - Computational Modeling + - Introduction to the Finite Element Methods + + and for rapid prototyping of new FEM elements. +* **Wide Compatibility** + Tested under Windows, macOS, Linux, and even Android (via Termux). Installation ------------ -The code is written in Python and it depends on ``numpy``, and ``scipy`` -and. It has been tested under Windows, Mac, Linux and Android. - -To install *SolidsPy* open a terminal and type: +SolidsPy runs on Python 3.11+ and depends on ``numpy`` and ``scipy``. -:: +Install via PyPI: + +.. code-block:: console pip install solidspy -To specify through a GUI the folder where the input -files are stored you will need to install `easygui `__. +For a GUI file selector, install: -To easily generate the required SolidsPy text files out of a -`Gmsh `__ model you will need -`meshio `__. +.. code-block:: console -These two can be installed with: + pip install easygui -:: +To convert Gmsh models (`gmsh.info `__) to SolidsPy input files, install: + +.. code-block:: console - pip install easygui pip install meshio +Install via Conda: + +.. code-block:: console + + conda install solidspy How to run a simple model ------------------------- @@ -153,23 +157,23 @@ Citation To cite SolidsPy in publications use - Nicolás Guarín-Zapata, Juan Gomez (2020). SolidsPy: Version 1.0.16 - (Version v1.0.16). Zenodo. http://doi.org/10.5281/zenodo.4029270 + Nicolás Guarín-Zapata, Juan Gomez (2025). SolidsPy: Version 2.0.0 + (Version v2.0.0). Zenodo. http://doi.org/10.5281/zenodo.4029270 A BibTeX entry for LaTeX users is .. code:: bibtex @software{solidspy, - title = {SolidsPy: 2D-Finite Element Analysis with Python}, - version = {1.0.16}, + title = {SolidsPy: 2D/3D-Finite Element Analysis with Python}, + version = {2.0.0}, author = {Guarín-Zapata, Nicolás and Gómez, Juan}, year = 2020, keywords = {Python, Finite elements, Scientific computing, Computational mechanics}, abstract = {SolidsPy is a simple finite element analysis code for - 2D elasticity problems. The code uses as input simple-to-create text + 2D/3D elasticity problems. The code uses as input simple-to-create text files defining a model in terms of nodal, element, material and load data.}, url = {https://github.com/AppliedMechanics-EAFIT/SolidsPy}, doi = {http://doi.org/10.5281/zenodo.4029270} - } + } \ No newline at end of file diff --git a/docs/advanced/membrane_vibration.rst b/docs/advanced/membrane_vibration.rst index ee500c1..d5ccddb 100644 --- a/docs/advanced/membrane_vibration.rst +++ b/docs/advanced/membrane_vibration.rst @@ -190,7 +190,7 @@ to compute the matrices. .. code:: ipython3 - assem_op, bc_array, neq = ass.DME(cons, elements, + assem_op, bc_array, neq = ass.node2dof(cons, elements, ndof_node=1, ndof_el_max=6) .. code:: ipython3 diff --git a/docs/conf.py b/docs/conf.py index 0c74d6c..90a16cc 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -53,7 +53,7 @@ # General information about the project. project = 'SolidsPy' -copyright = u'2023, Nicolás Guarín-Zapata & Juan Gómez' +copyright = u'2025, Nicolás Guarín-Zapata & Juan Gómez' author = u'Nicolás Guarín-Zapata & Juan Gómez' # The version info for the project you're documenting, acts as replacement for @@ -70,7 +70,7 @@ # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. -language = None +language = 'en' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. diff --git a/docs/modules.rst b/docs/modules.rst index f20701f..7f81e5e 100644 --- a/docs/modules.rst +++ b/docs/modules.rst @@ -15,28 +15,28 @@ SolidsPy have the following modules: - ``postprocesor.py``: Several results handling subroutines. -.. automodule:: solids_GUI +.. automodule:: solidspy.solids_GUI :members: -.. automodule:: assemutil +.. automodule:: solidspy.assemutil :members: -.. automodule:: femutil +.. automodule:: solidspy.femutil :members: -.. automodule:: gaussutil +.. automodule:: solidspy.gaussutil :members: -.. automodule:: preprocesor +.. automodule:: solidspy.preprocesor :members: -.. automodule:: postprocesor +.. automodule:: solidspy.postprocesor :members: -.. automodule:: solutil +.. automodule:: solidspy.solutil :members: -.. automodule:: uelutil +.. automodule:: solidspy.uelutil :members: diff --git a/docs/readme.rst b/docs/readme.rst index 251a438..aaee76e 100644 --- a/docs/readme.rst +++ b/docs/readme.rst @@ -1,5 +1,5 @@ -SolidsPy: 2D-Finite Element Analysis with Python -================================================ +SolidsPy: 2D/3D-Finite Element Analysis with Python +==================================================== .. figure:: https://raw.githubusercontent.com/AppliedMechanics-EAFIT/SolidsPy/master/docs/img/wrench.png :alt: Wrench under bending. @@ -20,7 +20,7 @@ SolidsPy: 2D-Finite Element Analysis with Python :target: https://zenodo.org/badge/latestdoi/48294591 -A simple finite element analysis code for 2D elasticity problems. +A simple finite element analysis code for 2D/3D elasticity problems. The code uses as input simple-to-create text files defining a model in terms of nodal, element, material and load data. @@ -153,7 +153,7 @@ Citation To cite SolidsPy in publications use - Nicolás Guarín-Zapata, Juan Gomez (2023). SolidsPy: Version 1.1.0 + Nicolás Guarín-Zapata, Juan Gomez (2025). SolidsPy: Version 1.1.0 (Version v1.1.0). Zenodo. A BibTeX entry for LaTeX users is @@ -161,13 +161,13 @@ A BibTeX entry for LaTeX users is .. code:: bibtex @software{solidspy, - title = {SolidsPy: 2D-Finite Element Analysis with Python}, + title = {SolidsPy: 2D/3D-Finite Element Analysis with Python}, version = {1.1.0}, author = {Guarín-Zapata, Nicolás and Gómez, Juan}, - year = 2023, + year = 2025, keywords = {Python, Finite elements, Scientific computing, Computational mechanics}, abstract = {SolidsPy is a simple finite element analysis code for - 2D elasticity problems. The code uses as input simple-to-create text + 2D/3D elasticity problems. The code uses as input simple-to-create text files defining a model in terms of nodal, element, material and load data.}, url = {https://github.com/AppliedMechanics-EAFIT/SolidsPy}, diff --git a/examples/3d_structures/3d_structure.ipynb b/examples/3d_structures/3d_structure.ipynb new file mode 100644 index 0000000..e0f2170 --- /dev/null +++ b/examples/3d_structures/3d_structure.ipynb @@ -0,0 +1,393 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3D Finite Element Analysis with SolidSPy\n", + "\n", + "In this notebook, we:\n", + "- Generate a **3D mesh** for a rectangular domain using a custom `structure_3d.py` script.\n", + "- **Assemble** the global stiffness matrix using SolidSPy's subroutines.\n", + "- **Apply** point loads at the top face of the 3D block.\n", + "- **Solve** for the displacements using a static solver.\n", + "- **Post-process** and **plot** the resulting stress fields, boundary conditions, and load arrows.\n", + "\n", + "Make sure to have:\n", + "- `structure_3d.py` in the **same directory** as this notebook.\n", + "- **`solidsypy`** installed (`pip install solidsypy`).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Imports\n", + "\n", + "We import **NumPy** and the necessary modules from **SolidSPy** (`assemutil`, `postprocesor`, `uelutil`, and `solutil`).\n", + "We also import our custom function `structure_3d` for mesh generation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import solidspy.assemutil as ass\n", + "import solidspy.postprocesor as pos\n", + "import solidspy.uelutil as uel\n", + "import solidspy.solutil as sol\n", + "from generate_3d import structure_3d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Geometry and Material Setup\n", + "\n", + "Here we define the **dimensions** of our 3D domain:\n", + "- `L = 10` (x-length)\n", + "- `H = 10` (y-length)\n", + "- `W = 30` (z-length)\n", + "\n", + "We also specify:\n", + "- `E` (Young's modulus)\n", + "- `v` (Poisson's ratio)\n", + "- `(nx, ny, nz)` as the number of elements in each direction." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry parameters\n", + "L = 10.0 # X dimension\n", + "H = 10.0 # Y dimension\n", + "W = 30.0 # Z dimension\n", + "\n", + "# Material properties\n", + "E = 206.8e9 # Young's modulus (Pa)\n", + "v = 0.28 # Poisson's ratio\n", + "\n", + "# Mesh resolution\n", + "nx = 10 # subdivisions in X\n", + "ny = 10 # subdivisions in Y\n", + "nz = 10 # subdivisions in Z" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Load Definitions\n", + "\n", + "We'll define **point loads** applied at the top face (`z = 30`). In this example:\n", + "- All loads are in the **Y direction** (just as an illustrative choice).\n", + "- We specify different **positions** on the top face to apply these loads.\n", + "\n", + "Later, we call `structure_3d(...)` with these load directions and positions." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Define load directions (always in Y, for example)\n", + "load_directions_3d = np.array([\n", + " [0, 1, 0], # Load #1 in Y\n", + " [0, 1, 0], # Load #2 in Y\n", + " [0, 1, 0] # Load #3 in Y\n", + "])\n", + "\n", + "# Define load positions (z = 30 top face)\n", + "load_positions_3d = np.array([\n", + " [5, 5, 30], # near center\n", + " [5, 1, 30], # near corner\n", + " [5, 8, 30] # another corner\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Mesh Generation via `structure_3d`\n", + "\n", + "We now generate:\n", + "- `nodes`: global coordinates of each node.\n", + "- `mats`: material data per element.\n", + "- `els`: connectivity of each element.\n", + "- `loads`: array of point loads.\n", + "- `idx_BC`: index of boundary conditions.\n", + "\n", + "Here, we pass our geometry, material, and load definitions to the `structure_3d` function." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mesh generation complete.\n", + "Number of nodes: 1331\n", + "Number of elements: 1000\n" + ] + } + ], + "source": [ + "nodes, mats, els, loads, idx_BC = structure_3d(\n", + " L=L,\n", + " H=H,\n", + " W=W,\n", + " E=E,\n", + " v=v,\n", + " nx=nx,\n", + " ny=ny,\n", + " nz=nz,\n", + " dirs=load_directions_3d,\n", + " positions=load_positions_3d\n", + ")\n", + "print(\"Mesh generation complete.\")\n", + "print(f\"Number of nodes: {nodes.shape[0]}\")\n", + "print(f\"Number of elements: {els.shape[0]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. System Assembly\n", + "\n", + "We assemble the global stiffness matrix and the global force vector.\n", + "- `dim_problem = 3` for 3D.\n", + "- `nnodes = 8` for Hexa8 elements.\n", + "- We call `ass.node2dof(...)` to generate the DOF mapping.\n", + "- Then `ass.assembler(...)` to build the global stiffness matrix.\n", + "- Finally, `ass.loadasem(...)` to assemble the right-hand side (load vector)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of equations (neq): 2420\n", + "System assembly complete.\n" + ] + } + ], + "source": [ + "dim_problem = 3\n", + "nnodes = 8\n", + "uel_func = uel.elast_hex8 # Element routine for hexa8\n", + "\n", + "# Create DOF mapping\n", + "assem_op, IBC, neq = ass.node2dof(\n", + " nodes[:, -dim_problem:], els, ndof_el_max=nnodes * dim_problem\n", + ")\n", + "print(f\"Number of equations (neq): {neq}\")\n", + "\n", + "# Assemble global stiffness matrix\n", + "stiff_mat, _ = ass.assembler(\n", + " els, mats, nodes[:, :-dim_problem], neq, assem_op, uel=uel_func\n", + ")\n", + "\n", + "# Assemble load vector\n", + "rhs_vec = ass.loadasem(loads, IBC, neq)\n", + "print(\"System assembly complete.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Static System Solution\n", + "\n", + "We solve the linear system \\( \\mathbf{K} \\mathbf{u} = \\mathbf{f} \\) for the nodal displacements \\( \\mathbf{u} \\)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "System solution (displacements) complete.\n" + ] + } + ], + "source": [ + "# Solve for displacements\n", + "disp = sol.static_sol(stiff_mat, rhs_vec)\n", + "# Map the solution back to all nodes\n", + "UCI = pos.complete_disp(IBC, nodes, disp, ndof_node=dim_problem)\n", + "\n", + "print(\"System solution (displacements) complete.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Post-Processing\n", + "\n", + "We compute **strain** and **stress** at each node, using SolidSPy's `strain_nodes_3d`. Then we **normalize** the loads for better visualization of load arrows." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Post-processing: strain, stress, and load normalization complete.\n" + ] + } + ], + "source": [ + "if dim_problem == 3:\n", + " E_nodes, S_nodes = pos.strain_nodes_3d(nodes, els, mats[:, :2], UCI)\n", + "else:\n", + " E_nodes, S_nodes = pos.strain_nodes(nodes, els, mats[:, :2], UCI)\n", + "\n", + "# Normalize load vectors for plotting clarity\n", + "max_force_component = np.max(np.abs(loads[:, 1:4]))\n", + "if max_force_component > 1e-14:\n", + " loads[:, 1:4] /= max_force_component\n", + "\n", + "print(\"Post-processing: strain, stress, and load normalization complete.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Visualization\n", + "\n", + "Finally, we use `fields_plot_3d` to display:\n", + "- The **stress** distribution.\n", + "- The **boundary conditions** (`show_BC=True`).\n", + "- The **load arrows** (`show_loads=True`).\n", + "\n", + "We also enable edges for the mesh, color the arrows in **blue**, and set a larger `arrow_scale`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kssgarcia/anaconda3/envs/solids-test/lib/python3.12/site-packages/pyvista/jupyter/notebook.py:37: UserWarning: Failed to use notebook backend: \n", + "\n", + "No module named 'trame'\n", + "\n", + "Falling back to a static output.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Visualization complete. Look at the plot above.\n" + ] + } + ], + "source": [ + "pos.fields_plot_3d(\n", + " nodes,\n", + " els,\n", + " loads,\n", + " idx_BC,\n", + " S_nodes,\n", + " E_nodes,\n", + " nnodes=8,\n", + " data_type='stress',\n", + " show_BC=True,\n", + " show_loads=True,\n", + " arrow_scale=2.0,\n", + " arrow_color=\"blue\",\n", + " cmap=\"viridis\",\n", + " show_axes=True,\n", + " show_bounds=False,\n", + " show_edges=True\n", + ")\n", + "\n", + "print(\"\\nVisualization complete. Look at the plot above.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Conclusion\n", + "\n", + "You have successfully:\n", + "1. Created a 3D FEM mesh.\n", + "2. Assembled and solved the linear system.\n", + "3. Visualized the stress field, boundary conditions, and loads.\n", + "\n", + "Feel free to modify any parameters (dimensions, mesh size, loads, material properties) to explore various configurations!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "solids-test", + "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.8" + }, + "name": "example_3D_fem" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/3d_structures/generate_3d.py b/examples/3d_structures/generate_3d.py new file mode 100644 index 0000000..0240e14 --- /dev/null +++ b/examples/3d_structures/generate_3d.py @@ -0,0 +1,129 @@ +import numpy as np +from typing import Tuple +from numpy.typing import NDArray + +def structure_3d( + L: float = 10.0, + H: float = 10.0, + W: float = 10.0, + E: float = 206.8e9, + v: float = 0.28, + nx: int = 10, + ny: int = 10, + nz: int = 10, + dirs: NDArray[np.float64] = np.array([]), + positions: NDArray[np.float64] = np.array([]) +) -> Tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.int_], NDArray[np.float64], NDArray[np.int_]]: + """ + Make the mesh for a cubic model with cantilever constraints in 3D. + + Parameters + ---------- + L : float, optional + Length of the structure (x-direction), by default 10.0 + H : float, optional + Height of the structure (y-direction), by default 10.0 + W : float, optional + Width of the structure (z-direction), by default 10.0 + E : float, optional + Young's modulus, by default 206.8e9 + v : float, optional + Poisson's ratio, by default 0.28 + nx : int, optional + Number of elements in the x direction, by default 10 + ny : int, optional + Number of elements in the y direction, by default 10 + nz : int, optional + Number of elements in the z direction, by default 10 + dirs : NDArray[np.float64], optional + Array of load directions, shape (n_loads, 3). + Example: [[0,1,0],[1,0,0],[0,0,-1]] + By default an empty array. + positions : NDArray[np.float64], optional + Array of load positions (in grid indexing), shape (n_loads, 3). + Example: [[5,5,9], [1,1,9], [8,8,9]] + By default an empty array. + + Returns + ------- + nodes : NDArray[np.float64] + Node array of shape ((nx+1)*(ny+1)*(nz+1), 7). + Columns: [node_id, x, y, z, BC_x, BC_y, BC_z]. + mats : NDArray[np.float64] + Material properties array of shape (number_of_elements, 3). + Each row: [E, v, placeholder]. + els : NDArray[np.int_] + Element connectivity array of shape (nx*ny*nz, 11). + For example: [element_id, material_id, 0, n0, n2, n3, n1, n4, n6, n7, n5]. + loads : NDArray[np.float64] + Loads array of shape (dirs.shape[0], 4). + Columns: [node_id, Fx, Fy, Fz]. + idx_BC : NDArray[np.int_] + Indices of nodes on the constrained face (z = 0). + """ + # Generate 3D grid of nodes + x = np.linspace(-L / 2, L / 2, nx + 1) + y = np.linspace(-H / 2, H / 2, ny + 1) + z = np.linspace(0, W, nz + 1) + xv, yv, zv = np.meshgrid(x, y, z, indexing='ij') + + nodes = np.zeros(((nx + 1) * (ny + 1) * (nz + 1), 7)) + nodes[:, 0] = np.arange(nodes.shape[0]) # Node IDs + nodes[:, 1] = xv.ravel() + nodes[:, 2] = yv.ravel() + nodes[:, 3] = zv.ravel() + + # Build hexahedral elements + els_list = [] + count = 0 + for i in range(nx): + for j in range(ny): + for k in range(nz): + n0 = k + (nz + 1) * (j + (ny + 1) * i) + n1 = n0 + 1 + n2 = n0 + (nz + 1) + n3 = n2 + 1 + n4 = n0 + (nz + 1) * (ny + 1) + n5 = n4 + 1 + n6 = n4 + (nz + 1) + n7 = n6 + 1 + # [element_id, material_id, 0, node0, node2, node3, node1, node4, node6, node7, node5] + els_list.append([count, 9, 0, n0, n2, n3, n1, n4, n6, n7, n5]) + count += 1 + els = np.array(els_list, dtype=int) + + # Assign material properties + mats = np.zeros((els.shape[0], 3)) + mats[:, 0] = E + mats[:, 1] = v + mats[:, 2] = 1 + + # Apply constraints on face z = 0 + mask_z0 = (nodes[:, 3] == 0.0) + nodes[mask_z0, 4] = -1 # BC_x + nodes[mask_z0, 5] = -1 # BC_y + nodes[mask_z0, 6] = -1 # BC_z + idx_BC = nodes[mask_z0, 0].astype(int) + + # Define loads on face z = W + loads = np.zeros((dirs.shape[0], 4)) + mask_load = (nodes[:, 3] == W) + node_indices = np.where(mask_load)[0] + + # The user supplies positions in a "grid" sense: [x_index, y_index, z_index]. + # We slice out the correct nodes from node_indices. Implementation is up to the user. + # Example: node_indices_selected = ... + # For demonstration, the code uses the provided positions as if + # positions[:,0] is x_index, positions[:,1] is y_index, + # and we assume z_index = positions[:,2] (already at z=W). + # This line is a placeholder; adjust indexing logic as needed. + node_indices_selected = node_indices[ + positions[:, 0] * (ny + 1) + positions[:, 1] + ] + + loads[:, 0] = node_indices_selected + loads[:, 1] = dirs[:, 0] # Fx + loads[:, 2] = dirs[:, 1] # Fy + loads[:, 3] = dirs[:, 2] # Fz + + return nodes, mats, els, loads, idx_BC \ No newline at end of file diff --git a/examples/beam_convergence/beam_convergence.ipynb b/examples/beam_convergence/beam_convergence.ipynb index 0f5ff02..d803c86 100755 --- a/examples/beam_convergence/beam_convergence.ipynb +++ b/examples/beam_convergence/beam_convergence.ipynb @@ -300,8 +300,8 @@ " loads[:, 2] = P/ny\n", "\n", " # Assembly\n", - " DME, IBC, neq = ass.DME(nodes[:,-2:], els, ndof_el_max=8)\n", - " stiff, _ = ass.assembler(els, mats, nodes[:,:-2], neq, DME)\n", + " node2dof, IBC, neq = ass.node2dof(nodes[:,-2:], els, ndof_el_max=8)\n", + " stiff, _ = ass.assembler(els, mats, nodes[:,:-2], neq, node2dof)\n", " rhs = ass.loadasem(loads, IBC, neq)\n", "\n", " # Solution\n", diff --git a/examples/membrane_vibration/membrane.vtk b/examples/membrane_vibration/membrane.vtk index e5d0515..dd3f7ba 100644 Binary files a/examples/membrane_vibration/membrane.vtk and b/examples/membrane_vibration/membrane.vtk differ diff --git a/examples/membrane_vibration/membrane_vibration.ipynb b/examples/membrane_vibration/membrane_vibration.ipynb index 196fde0..700ccf9 100644 --- a/examples/membrane_vibration/membrane_vibration.ipynb +++ b/examples/membrane_vibration/membrane_vibration.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -210,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -240,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -257,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -277,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -297,17 +297,17 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "assem_op, bc_array, neq = ass.DME(cons, elements,\n", + "assem_op, bc_array, neq = ass.node2dof(cons, elements,\n", " ndof_node=1, ndof_el_max=6)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -324,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -334,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -344,7 +344,7 @@ " 6.25000122, 6.25000207, 7.25000259, 9.25000428, 10.25000925])" ] }, - "execution_count": 25, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -364,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -373,7 +373,7 @@ "array([ 2, 5, 5, 8, 10, 10, 13, 13, 17, 17])" ] }, - "execution_count": 26, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -395,7 +395,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -404,7 +404,7 @@ "False" ] }, - "execution_count": 27, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -422,12 +422,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n if (typeof WebSocket !== 'undefined') {\n return WebSocket;\n } else if (typeof MozWebSocket !== 'undefined') {\n return MozWebSocket;\n } else {\n alert(\n 'Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.'\n );\n }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = this.ws.binaryType !== undefined;\n\n if (!this.supports_binary) {\n var warnings = document.getElementById('mpl-warnings');\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent =\n 'This browser does not support binary websocket messages. ' +\n 'Performance may be slow.';\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = document.createElement('div');\n this.root.setAttribute('style', 'display: inline-block');\n this._root_extra_style(this.root);\n\n parent_element.appendChild(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message('supports_binary', { value: fig.supports_binary });\n fig.send_message('send_image_mode', {});\n if (fig.ratio !== 1) {\n fig.send_message('set_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\n }\n fig.send_message('refresh', {});\n };\n\n this.imageObj.onload = function () {\n if (fig.image_mode === 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function () {\n fig.ws.close();\n };\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n var titlebar = document.createElement('div');\n titlebar.classList =\n 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n var titletext = document.createElement('div');\n titletext.classList = 'ui-dialog-title';\n titletext.setAttribute(\n 'style',\n 'width: 100%; text-align: center; padding: 3px;'\n );\n titlebar.appendChild(titletext);\n this.root.appendChild(titlebar);\n this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n var fig = this;\n\n var canvas_div = (this.canvas_div = document.createElement('div'));\n canvas_div.setAttribute('tabindex', '0');\n canvas_div.setAttribute(\n 'style',\n 'border: 1px solid #ddd;' +\n 'box-sizing: content-box;' +\n 'clear: both;' +\n 'min-height: 1px;' +\n 'min-width: 1px;' +\n 'outline: 0;' +\n 'overflow: hidden;' +\n 'position: relative;' +\n 'resize: both;' +\n 'z-index: 2;'\n );\n\n function on_keyboard_event_closure(name) {\n return function (event) {\n return fig.key_event(event, name);\n };\n }\n\n canvas_div.addEventListener(\n 'keydown',\n on_keyboard_event_closure('key_press')\n );\n canvas_div.addEventListener(\n 'keyup',\n on_keyboard_event_closure('key_release')\n );\n\n this._canvas_extra_style(canvas_div);\n this.root.appendChild(canvas_div);\n\n var canvas = (this.canvas = document.createElement('canvas'));\n canvas.classList.add('mpl-canvas');\n canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'pointer-events: none;' +\n 'position: relative;' +\n 'z-index: 0;'\n );\n\n this.context = canvas.getContext('2d');\n\n var backingStore =\n this.context.backingStorePixelRatio ||\n this.context.webkitBackingStorePixelRatio ||\n this.context.mozBackingStorePixelRatio ||\n this.context.msBackingStorePixelRatio ||\n this.context.oBackingStorePixelRatio ||\n this.context.backingStorePixelRatio ||\n 1;\n\n this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n 'canvas'\n ));\n rubberband_canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'left: 0;' +\n 'pointer-events: none;' +\n 'position: absolute;' +\n 'top: 0;' +\n 'z-index: 1;'\n );\n\n // Apply a ponyfill if ResizeObserver is not implemented by browser.\n if (this.ResizeObserver === undefined) {\n if (window.ResizeObserver !== undefined) {\n this.ResizeObserver = window.ResizeObserver;\n } else {\n var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n this.ResizeObserver = obs.ResizeObserver;\n }\n }\n\n this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n // There's no need to resize if the WebSocket is not connected:\n // - If it is still connecting, then we will get an initial resize from\n // Python once it connects.\n // - If it has disconnected, then resizing will clear the canvas and\n // never get anything back to refill it, so better to not resize and\n // keep something visible.\n if (fig.ws.readyState != 1) {\n return;\n }\n var nentries = entries.length;\n for (var i = 0; i < nentries; i++) {\n var entry = entries[i];\n var width, height;\n if (entry.contentBoxSize) {\n if (entry.contentBoxSize instanceof Array) {\n // Chrome 84 implements new version of spec.\n width = entry.contentBoxSize[0].inlineSize;\n height = entry.contentBoxSize[0].blockSize;\n } else {\n // Firefox implements old version of spec.\n width = entry.contentBoxSize.inlineSize;\n height = entry.contentBoxSize.blockSize;\n }\n } else {\n // Chrome <84 implements even older version of spec.\n width = entry.contentRect.width;\n height = entry.contentRect.height;\n }\n\n // Keep the size of the canvas and rubber band canvas in sync with\n // the canvas container.\n if (entry.devicePixelContentBoxSize) {\n // Chrome 84 implements new version of spec.\n canvas.setAttribute(\n 'width',\n entry.devicePixelContentBoxSize[0].inlineSize\n );\n canvas.setAttribute(\n 'height',\n entry.devicePixelContentBoxSize[0].blockSize\n );\n } else {\n canvas.setAttribute('width', width * fig.ratio);\n canvas.setAttribute('height', height * fig.ratio);\n }\n /* This rescales the canvas back to display pixels, so that it\n * appears correct on HiDPI screens. */\n canvas.style.width = width + 'px';\n canvas.style.height = height + 'px';\n\n rubberband_canvas.setAttribute('width', width);\n rubberband_canvas.setAttribute('height', height);\n\n // And update the size in Python. We ignore the initial 0/0 size\n // that occurs as the element is placed into the DOM, which should\n // otherwise not happen due to the minimum size styling.\n if (width != 0 && height != 0) {\n fig.request_resize(width, height);\n }\n }\n });\n this.resizeObserverInstance.observe(canvas_div);\n\n function on_mouse_event_closure(name) {\n /* User Agent sniffing is bad, but WebKit is busted:\n * https://bugs.webkit.org/show_bug.cgi?id=144526\n * https://bugs.webkit.org/show_bug.cgi?id=181818\n * The worst that happens here is that they get an extra browser\n * selection when dragging, if this check fails to catch them.\n */\n var UA = navigator.userAgent;\n var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n if(isWebKit) {\n return function (event) {\n /* This prevents the web browser from automatically changing to\n * the text insertion cursor when the button is pressed. We\n * want to control all of the cursor setting manually through\n * the 'cursor' event from matplotlib */\n event.preventDefault()\n return fig.mouse_event(event, name);\n };\n } else {\n return function (event) {\n return fig.mouse_event(event, name);\n };\n }\n }\n\n canvas_div.addEventListener(\n 'mousedown',\n on_mouse_event_closure('button_press')\n );\n canvas_div.addEventListener(\n 'mouseup',\n on_mouse_event_closure('button_release')\n );\n canvas_div.addEventListener(\n 'dblclick',\n on_mouse_event_closure('dblclick')\n );\n // Throttle sequential mouse events to 1 every 20ms.\n canvas_div.addEventListener(\n 'mousemove',\n on_mouse_event_closure('motion_notify')\n );\n\n canvas_div.addEventListener(\n 'mouseenter',\n on_mouse_event_closure('figure_enter')\n );\n canvas_div.addEventListener(\n 'mouseleave',\n on_mouse_event_closure('figure_leave')\n );\n\n canvas_div.addEventListener('wheel', function (event) {\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n on_mouse_event_closure('scroll')(event);\n });\n\n canvas_div.appendChild(canvas);\n canvas_div.appendChild(rubberband_canvas);\n\n this.rubberband_context = rubberband_canvas.getContext('2d');\n this.rubberband_context.strokeStyle = '#000000';\n\n this._resize_canvas = function (width, height, forward) {\n if (forward) {\n canvas_div.style.width = width + 'px';\n canvas_div.style.height = height + 'px';\n }\n };\n\n // Disable right mouse context menu.\n canvas_div.addEventListener('contextmenu', function (_e) {\n event.preventDefault();\n return false;\n });\n\n function set_focus() {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'mpl-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n continue;\n }\n\n var button = (fig.buttons[name] = document.createElement('button'));\n button.classList = 'mpl-widget';\n button.setAttribute('role', 'button');\n button.setAttribute('aria-disabled', 'false');\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n var icon_img = document.createElement('img');\n icon_img.src = '_images/' + image + '.png';\n icon_img.srcset = '_images/' + image + '_large.png 2x';\n icon_img.alt = tooltip;\n button.appendChild(icon_img);\n\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n var fmt_picker = document.createElement('select');\n fmt_picker.classList = 'mpl-widget';\n toolbar.appendChild(fmt_picker);\n this.format_dropdown = fmt_picker;\n\n for (var ind in mpl.extensions) {\n var fmt = mpl.extensions[ind];\n var option = document.createElement('option');\n option.selected = fmt === mpl.default_extension;\n option.innerHTML = fmt;\n fmt_picker.appendChild(option);\n }\n\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n // which will in turn request a refresh of the image.\n this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n properties['type'] = type;\n properties['figure_id'] = this.id;\n this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n if (!this.waiting) {\n this.waiting = true;\n this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n var format_dropdown = fig.format_dropdown;\n var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n var size = msg['size'];\n if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n fig._resize_canvas(size[0], size[1], msg['forward']);\n fig.send_message('refresh', {});\n }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n var x0 = msg['x0'] / fig.ratio;\n var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n var x1 = msg['x1'] / fig.ratio;\n var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n x0 = Math.floor(x0) + 0.5;\n y0 = Math.floor(y0) + 0.5;\n x1 = Math.floor(x1) + 0.5;\n y1 = Math.floor(y1) + 0.5;\n var min_x = Math.min(x0, x1);\n var min_y = Math.min(y0, y1);\n var width = Math.abs(x1 - x0);\n var height = Math.abs(y1 - y0);\n\n fig.rubberband_context.clearRect(\n 0,\n 0,\n fig.canvas.width / fig.ratio,\n fig.canvas.height / fig.ratio\n );\n\n fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n for (var key in msg) {\n if (!(key in fig.buttons)) {\n continue;\n }\n fig.buttons[key].disabled = !msg[key];\n fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n if (msg['mode'] === 'PAN') {\n fig.buttons['Pan'].classList.add('active');\n fig.buttons['Zoom'].classList.remove('active');\n } else if (msg['mode'] === 'ZOOM') {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.add('active');\n } else {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.remove('active');\n }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Called whenever the canvas gets updated.\n this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n return function socket_on_message(evt) {\n if (evt.data instanceof Blob) {\n var img = evt.data;\n if (img.type !== 'image/png') {\n /* FIXME: We get \"Resource interpreted as Image but\n * transferred with MIME type text/plain:\" errors on\n * Chrome. But how to set the MIME type? It doesn't seem\n * to be part of the websocket stream */\n img.type = 'image/png';\n }\n\n /* Free the memory for the previous frames */\n if (fig.imageObj.src) {\n (window.URL || window.webkitURL).revokeObjectURL(\n fig.imageObj.src\n );\n }\n\n fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n img\n );\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n } else if (\n typeof evt.data === 'string' &&\n evt.data.slice(0, 21) === 'data:image/png;base64'\n ) {\n fig.imageObj.src = evt.data;\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n }\n\n var msg = JSON.parse(evt.data);\n var msg_type = msg['type'];\n\n // Call the \"handle_{type}\" callback, which takes\n // the figure and JSON message as its only arguments.\n try {\n var callback = fig['handle_' + msg_type];\n } catch (e) {\n console.log(\n \"No handler for the '\" + msg_type + \"' message type: \",\n msg\n );\n return;\n }\n\n if (callback) {\n try {\n // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n callback(fig, msg);\n } catch (e) {\n console.log(\n \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n e,\n e.stack,\n msg\n );\n }\n }\n };\n};\n\nfunction getModifiers(event) {\n var mods = [];\n if (event.ctrlKey) {\n mods.push('ctrl');\n }\n if (event.altKey) {\n mods.push('alt');\n }\n if (event.shiftKey) {\n mods.push('shift');\n }\n if (event.metaKey) {\n mods.push('meta');\n }\n return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n return Object.keys(original).reduce(function (obj, key) {\n if (typeof original[key] !== 'object') {\n obj[key] = original[key];\n }\n return obj;\n }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n if (name === 'button_press') {\n this.canvas.focus();\n this.canvas_div.focus();\n }\n\n // from https://stackoverflow.com/q/1114465\n var boundingRect = this.canvas.getBoundingClientRect();\n var x = (event.clientX - boundingRect.left) * this.ratio;\n var y = (event.clientY - boundingRect.top) * this.ratio;\n\n this.send_message(name, {\n x: x,\n y: y,\n button: event.button,\n step: event.step,\n modifiers: getModifiers(event),\n guiEvent: simpleKeys(event),\n });\n\n return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n // Prevent repeat events\n if (name === 'key_press') {\n if (event.key === this._key) {\n return;\n } else {\n this._key = event.key;\n }\n }\n if (name === 'key_release') {\n this._key = null;\n }\n\n var value = '';\n if (event.ctrlKey && event.key !== 'Control') {\n value += 'ctrl+';\n }\n else if (event.altKey && event.key !== 'Alt') {\n value += 'alt+';\n }\n else if (event.shiftKey && event.key !== 'Shift') {\n value += 'shift+';\n }\n\n value += 'k' + event.key;\n\n this._key_event_extra(event, name);\n\n this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n if (name === 'download') {\n this.handle_save(this, null);\n } else {\n this.send_message('toolbar_button', { name: name });\n }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n // Create a \"websocket\"-like object which calls the given IPython comm\n // object with the appropriate methods. Currently this is a non binary\n // socket, so there is still some room for performance tuning.\n var ws = {};\n\n ws.binaryType = comm.kernel.ws.binaryType;\n ws.readyState = comm.kernel.ws.readyState;\n function updateReadyState(_event) {\n if (comm.kernel.ws) {\n ws.readyState = comm.kernel.ws.readyState;\n } else {\n ws.readyState = 3; // Closed state.\n }\n }\n comm.kernel.ws.addEventListener('open', updateReadyState);\n comm.kernel.ws.addEventListener('close', updateReadyState);\n comm.kernel.ws.addEventListener('error', updateReadyState);\n\n ws.close = function () {\n comm.close();\n };\n ws.send = function (m) {\n //console.log('sending', m);\n comm.send(m);\n };\n // Register the callback with on_msg.\n comm.on_msg(function (msg) {\n //console.log('receiving', msg['content']['data'], msg);\n var data = msg['content']['data'];\n if (data['blob'] !== undefined) {\n data = {\n data: new Blob(msg['buffers'], { type: data['blob'] }),\n };\n }\n // Pass the mpl event to the overridden (by mpl) onmessage function.\n ws.onmessage(data);\n });\n return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n // This is the function which gets called when the mpl process\n // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n var id = msg.content.data.id;\n // Get hold of the div created by the display call when the Comm\n // socket was opened in Python.\n var element = document.getElementById(id);\n var ws_proxy = comm_websocket_adapter(comm);\n\n function ondownload(figure, _format) {\n window.open(figure.canvas.toDataURL());\n }\n\n var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n // web socket which is closed, not our websocket->open comm proxy.\n ws_proxy.onopen();\n\n fig.parent_element = element;\n fig.cell_info = mpl.find_output_cell(\"
\");\n if (!fig.cell_info) {\n console.error('Failed to find cell for figure', id, fig);\n return;\n }\n fig.cell_info[0].output_area.element.on(\n 'cleared',\n { fig: fig },\n fig._remove_fig_handler\n );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n var width = fig.canvas.width / fig.ratio;\n fig.cell_info[0].output_area.element.off(\n 'cleared',\n fig._remove_fig_handler\n );\n fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n // Update the output cell to use the data from the current canvas.\n fig.push_to_output();\n var dataURL = fig.canvas.toDataURL();\n // Re-enable the keyboard manager in IPython - without this line, in FF,\n // the notebook keyboard shortcuts fail.\n IPython.keyboard_manager.enable();\n fig.parent_element.innerHTML =\n '';\n fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n // Turn the data on the canvas into data in the output cell.\n var width = this.canvas.width / this.ratio;\n var dataURL = this.canvas.toDataURL();\n this.cell_info[1]['text/html'] =\n '';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Tell IPython that the notebook contents must change.\n IPython.notebook.set_dirty(true);\n this.send_message('ack', {});\n var fig = this;\n // Wait a second, then push the new image to the DOM so\n // that it is saved nicely (might be nice to debounce this).\n setTimeout(function () {\n fig.push_to_output();\n }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'btn-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n var button;\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n continue;\n }\n\n button = fig.buttons[name] = document.createElement('button');\n button.classList = 'btn btn-default';\n button.href = '#';\n button.title = name;\n button.innerHTML = '';\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n // Add the status bar.\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message pull-right';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n\n // Add the close button to the window.\n var buttongrp = document.createElement('div');\n buttongrp.classList = 'btn-group inline pull-right';\n button = document.createElement('button');\n button.classList = 'btn btn-mini btn-primary';\n button.href = '#';\n button.title = 'Stop Interaction';\n button.innerHTML = '';\n button.addEventListener('click', function (_evt) {\n fig.handle_close(fig, {});\n });\n button.addEventListener(\n 'mouseover',\n on_mouseover_closure('Stop Interaction')\n );\n buttongrp.appendChild(button);\n var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n var fig = event.data.fig;\n if (event.target !== this) {\n // Ignore bubbled events from children.\n return;\n }\n fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n // this is important to make the div 'focusable\n el.setAttribute('tabindex', 0);\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n } else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n // Check for shift+enter\n if (event.shiftKey && event.which === 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i = 0; i < ncells; i++) {\n var cell = cells[i];\n if (cell.cell_type === 'code') {\n for (var j = 0; j < cell.output_area.outputs.length; j++) {\n var data = cell.output_area.outputs[j];\n if (data.data) {\n // IPython >= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] === html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n IPython.notebook.kernel.comm_manager.register_target(\n 'matplotlib',\n mpl.mpl_figure_comm\n );\n}\n", + "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n if (typeof WebSocket !== 'undefined') {\n return WebSocket;\n } else if (typeof MozWebSocket !== 'undefined') {\n return MozWebSocket;\n } else {\n alert(\n 'Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.'\n );\n }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = this.ws.binaryType !== undefined;\n\n if (!this.supports_binary) {\n var warnings = document.getElementById('mpl-warnings');\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent =\n 'This browser does not support binary websocket messages. ' +\n 'Performance may be slow.';\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = document.createElement('div');\n this.root.setAttribute('style', 'display: inline-block');\n this._root_extra_style(this.root);\n\n parent_element.appendChild(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message('supports_binary', { value: fig.supports_binary });\n fig.send_message('send_image_mode', {});\n if (fig.ratio !== 1) {\n fig.send_message('set_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\n }\n fig.send_message('refresh', {});\n };\n\n this.imageObj.onload = function () {\n if (fig.image_mode === 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function () {\n fig.ws.close();\n };\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n var titlebar = document.createElement('div');\n titlebar.classList =\n 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n var titletext = document.createElement('div');\n titletext.classList = 'ui-dialog-title';\n titletext.setAttribute(\n 'style',\n 'width: 100%; text-align: center; padding: 3px;'\n );\n titlebar.appendChild(titletext);\n this.root.appendChild(titlebar);\n this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n var fig = this;\n\n var canvas_div = (this.canvas_div = document.createElement('div'));\n canvas_div.setAttribute('tabindex', '0');\n canvas_div.setAttribute(\n 'style',\n 'border: 1px solid #ddd;' +\n 'box-sizing: content-box;' +\n 'clear: both;' +\n 'min-height: 1px;' +\n 'min-width: 1px;' +\n 'outline: 0;' +\n 'overflow: hidden;' +\n 'position: relative;' +\n 'resize: both;' +\n 'z-index: 2;'\n );\n\n function on_keyboard_event_closure(name) {\n return function (event) {\n return fig.key_event(event, name);\n };\n }\n\n canvas_div.addEventListener(\n 'keydown',\n on_keyboard_event_closure('key_press')\n );\n canvas_div.addEventListener(\n 'keyup',\n on_keyboard_event_closure('key_release')\n );\n\n this._canvas_extra_style(canvas_div);\n this.root.appendChild(canvas_div);\n\n var canvas = (this.canvas = document.createElement('canvas'));\n canvas.classList.add('mpl-canvas');\n canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'pointer-events: none;' +\n 'position: relative;' +\n 'z-index: 0;'\n );\n\n this.context = canvas.getContext('2d');\n\n var backingStore =\n this.context.backingStorePixelRatio ||\n this.context.webkitBackingStorePixelRatio ||\n this.context.mozBackingStorePixelRatio ||\n this.context.msBackingStorePixelRatio ||\n this.context.oBackingStorePixelRatio ||\n this.context.backingStorePixelRatio ||\n 1;\n\n this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n 'canvas'\n ));\n rubberband_canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'left: 0;' +\n 'pointer-events: none;' +\n 'position: absolute;' +\n 'top: 0;' +\n 'z-index: 1;'\n );\n\n // Apply a ponyfill if ResizeObserver is not implemented by browser.\n if (this.ResizeObserver === undefined) {\n if (window.ResizeObserver !== undefined) {\n this.ResizeObserver = window.ResizeObserver;\n } else {\n var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n this.ResizeObserver = obs.ResizeObserver;\n }\n }\n\n this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n // There's no need to resize if the WebSocket is not connected:\n // - If it is still connecting, then we will get an initial resize from\n // Python once it connects.\n // - If it has disconnected, then resizing will clear the canvas and\n // never get anything back to refill it, so better to not resize and\n // keep something visible.\n if (fig.ws.readyState != 1) {\n return;\n }\n var nentries = entries.length;\n for (var i = 0; i < nentries; i++) {\n var entry = entries[i];\n var width, height;\n if (entry.contentBoxSize) {\n if (entry.contentBoxSize instanceof Array) {\n // Chrome 84 implements new version of spec.\n width = entry.contentBoxSize[0].inlineSize;\n height = entry.contentBoxSize[0].blockSize;\n } else {\n // Firefox implements old version of spec.\n width = entry.contentBoxSize.inlineSize;\n height = entry.contentBoxSize.blockSize;\n }\n } else {\n // Chrome <84 implements even older version of spec.\n width = entry.contentRect.width;\n height = entry.contentRect.height;\n }\n\n // Keep the size of the canvas and rubber band canvas in sync with\n // the canvas container.\n if (entry.devicePixelContentBoxSize) {\n // Chrome 84 implements new version of spec.\n canvas.setAttribute(\n 'width',\n entry.devicePixelContentBoxSize[0].inlineSize\n );\n canvas.setAttribute(\n 'height',\n entry.devicePixelContentBoxSize[0].blockSize\n );\n } else {\n canvas.setAttribute('width', width * fig.ratio);\n canvas.setAttribute('height', height * fig.ratio);\n }\n /* This rescales the canvas back to display pixels, so that it\n * appears correct on HiDPI screens. */\n canvas.style.width = width + 'px';\n canvas.style.height = height + 'px';\n\n rubberband_canvas.setAttribute('width', width);\n rubberband_canvas.setAttribute('height', height);\n\n // And update the size in Python. We ignore the initial 0/0 size\n // that occurs as the element is placed into the DOM, which should\n // otherwise not happen due to the minimum size styling.\n if (width != 0 && height != 0) {\n fig.request_resize(width, height);\n }\n }\n });\n this.resizeObserverInstance.observe(canvas_div);\n\n function on_mouse_event_closure(name) {\n /* User Agent sniffing is bad, but WebKit is busted:\n * https://bugs.webkit.org/show_bug.cgi?id=144526\n * https://bugs.webkit.org/show_bug.cgi?id=181818\n * The worst that happens here is that they get an extra browser\n * selection when dragging, if this check fails to catch them.\n */\n var UA = navigator.userAgent;\n var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n if(isWebKit) {\n return function (event) {\n /* This prevents the web browser from automatically changing to\n * the text insertion cursor when the button is pressed. We\n * want to control all of the cursor setting manually through\n * the 'cursor' event from matplotlib */\n event.preventDefault()\n return fig.mouse_event(event, name);\n };\n } else {\n return function (event) {\n return fig.mouse_event(event, name);\n };\n }\n }\n\n canvas_div.addEventListener(\n 'mousedown',\n on_mouse_event_closure('button_press')\n );\n canvas_div.addEventListener(\n 'mouseup',\n on_mouse_event_closure('button_release')\n );\n canvas_div.addEventListener(\n 'dblclick',\n on_mouse_event_closure('dblclick')\n );\n // Throttle sequential mouse events to 1 every 20ms.\n canvas_div.addEventListener(\n 'mousemove',\n on_mouse_event_closure('motion_notify')\n );\n\n canvas_div.addEventListener(\n 'mouseenter',\n on_mouse_event_closure('figure_enter')\n );\n canvas_div.addEventListener(\n 'mouseleave',\n on_mouse_event_closure('figure_leave')\n );\n\n canvas_div.addEventListener('wheel', function (event) {\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n on_mouse_event_closure('scroll')(event);\n });\n\n canvas_div.appendChild(canvas);\n canvas_div.appendChild(rubberband_canvas);\n\n this.rubberband_context = rubberband_canvas.getContext('2d');\n this.rubberband_context.strokeStyle = '#000000';\n\n this._resize_canvas = function (width, height, forward) {\n if (forward) {\n canvas_div.style.width = width + 'px';\n canvas_div.style.height = height + 'px';\n }\n };\n\n // Disable right mouse context menu.\n canvas_div.addEventListener('contextmenu', function (_e) {\n event.preventDefault();\n return false;\n });\n\n function set_focus() {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'mpl-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n continue;\n }\n\n var button = (fig.buttons[name] = document.createElement('button'));\n button.classList = 'mpl-widget';\n button.setAttribute('role', 'button');\n button.setAttribute('aria-disabled', 'false');\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n var icon_img = document.createElement('img');\n icon_img.src = '_images/' + image + '.png';\n icon_img.srcset = '_images/' + image + '_large.png 2x';\n icon_img.alt = tooltip;\n button.appendChild(icon_img);\n\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n var fmt_picker = document.createElement('select');\n fmt_picker.classList = 'mpl-widget';\n toolbar.appendChild(fmt_picker);\n this.format_dropdown = fmt_picker;\n\n for (var ind in mpl.extensions) {\n var fmt = mpl.extensions[ind];\n var option = document.createElement('option');\n option.selected = fmt === mpl.default_extension;\n option.innerHTML = fmt;\n fmt_picker.appendChild(option);\n }\n\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n // which will in turn request a refresh of the image.\n this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n properties['type'] = type;\n properties['figure_id'] = this.id;\n this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n if (!this.waiting) {\n this.waiting = true;\n this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n var format_dropdown = fig.format_dropdown;\n var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n var size = msg['size'];\n if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n fig._resize_canvas(size[0], size[1], msg['forward']);\n fig.send_message('refresh', {});\n }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n var x0 = msg['x0'] / fig.ratio;\n var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n var x1 = msg['x1'] / fig.ratio;\n var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n x0 = Math.floor(x0) + 0.5;\n y0 = Math.floor(y0) + 0.5;\n x1 = Math.floor(x1) + 0.5;\n y1 = Math.floor(y1) + 0.5;\n var min_x = Math.min(x0, x1);\n var min_y = Math.min(y0, y1);\n var width = Math.abs(x1 - x0);\n var height = Math.abs(y1 - y0);\n\n fig.rubberband_context.clearRect(\n 0,\n 0,\n fig.canvas.width / fig.ratio,\n fig.canvas.height / fig.ratio\n );\n\n fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n for (var key in msg) {\n if (!(key in fig.buttons)) {\n continue;\n }\n fig.buttons[key].disabled = !msg[key];\n fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n if (msg['mode'] === 'PAN') {\n fig.buttons['Pan'].classList.add('active');\n fig.buttons['Zoom'].classList.remove('active');\n } else if (msg['mode'] === 'ZOOM') {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.add('active');\n } else {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.remove('active');\n }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Called whenever the canvas gets updated.\n this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n return function socket_on_message(evt) {\n if (evt.data instanceof Blob) {\n var img = evt.data;\n if (img.type !== 'image/png') {\n /* FIXME: We get \"Resource interpreted as Image but\n * transferred with MIME type text/plain:\" errors on\n * Chrome. But how to set the MIME type? It doesn't seem\n * to be part of the websocket stream */\n img.type = 'image/png';\n }\n\n /* Free the memory for the previous frames */\n if (fig.imageObj.src) {\n (window.URL || window.webkitURL).revokeObjectURL(\n fig.imageObj.src\n );\n }\n\n fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n img\n );\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n } else if (\n typeof evt.data === 'string' &&\n evt.data.slice(0, 21) === 'data:image/png;base64'\n ) {\n fig.imageObj.src = evt.data;\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n }\n\n var msg = JSON.parse(evt.data);\n var msg_type = msg['type'];\n\n // Call the \"handle_{type}\" callback, which takes\n // the figure and JSON message as its only arguments.\n try {\n var callback = fig['handle_' + msg_type];\n } catch (e) {\n console.log(\n \"No handler for the '\" + msg_type + \"' message type: \",\n msg\n );\n return;\n }\n\n if (callback) {\n try {\n // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n callback(fig, msg);\n } catch (e) {\n console.log(\n \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n e,\n e.stack,\n msg\n );\n }\n }\n };\n};\n\nfunction getModifiers(event) {\n var mods = [];\n if (event.ctrlKey) {\n mods.push('ctrl');\n }\n if (event.altKey) {\n mods.push('alt');\n }\n if (event.shiftKey) {\n mods.push('shift');\n }\n if (event.metaKey) {\n mods.push('meta');\n }\n return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n return Object.keys(original).reduce(function (obj, key) {\n if (typeof original[key] !== 'object') {\n obj[key] = original[key];\n }\n return obj;\n }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n if (name === 'button_press') {\n this.canvas.focus();\n this.canvas_div.focus();\n }\n\n // from https://stackoverflow.com/q/1114465\n var boundingRect = this.canvas.getBoundingClientRect();\n var x = (event.clientX - boundingRect.left) * this.ratio;\n var y = (event.clientY - boundingRect.top) * this.ratio;\n\n this.send_message(name, {\n x: x,\n y: y,\n button: event.button,\n step: event.step,\n buttons: event.buttons,\n modifiers: getModifiers(event),\n guiEvent: simpleKeys(event),\n });\n\n return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n // Prevent repeat events\n if (name === 'key_press') {\n if (event.key === this._key) {\n return;\n } else {\n this._key = event.key;\n }\n }\n if (name === 'key_release') {\n this._key = null;\n }\n\n var value = '';\n if (event.ctrlKey && event.key !== 'Control') {\n value += 'ctrl+';\n }\n else if (event.altKey && event.key !== 'Alt') {\n value += 'alt+';\n }\n else if (event.shiftKey && event.key !== 'Shift') {\n value += 'shift+';\n }\n\n value += 'k' + event.key;\n\n this._key_event_extra(event, name);\n\n this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n if (name === 'download') {\n this.handle_save(this, null);\n } else {\n this.send_message('toolbar_button', { name: name });\n }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n // Create a \"websocket\"-like object which calls the given IPython comm\n // object with the appropriate methods. Currently this is a non binary\n // socket, so there is still some room for performance tuning.\n var ws = {};\n\n ws.binaryType = comm.kernel.ws.binaryType;\n ws.readyState = comm.kernel.ws.readyState;\n function updateReadyState(_event) {\n if (comm.kernel.ws) {\n ws.readyState = comm.kernel.ws.readyState;\n } else {\n ws.readyState = 3; // Closed state.\n }\n }\n comm.kernel.ws.addEventListener('open', updateReadyState);\n comm.kernel.ws.addEventListener('close', updateReadyState);\n comm.kernel.ws.addEventListener('error', updateReadyState);\n\n ws.close = function () {\n comm.close();\n };\n ws.send = function (m) {\n //console.log('sending', m);\n comm.send(m);\n };\n // Register the callback with on_msg.\n comm.on_msg(function (msg) {\n //console.log('receiving', msg['content']['data'], msg);\n var data = msg['content']['data'];\n if (data['blob'] !== undefined) {\n data = {\n data: new Blob(msg['buffers'], { type: data['blob'] }),\n };\n }\n // Pass the mpl event to the overridden (by mpl) onmessage function.\n ws.onmessage(data);\n });\n return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n // This is the function which gets called when the mpl process\n // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n var id = msg.content.data.id;\n // Get hold of the div created by the display call when the Comm\n // socket was opened in Python.\n var element = document.getElementById(id);\n var ws_proxy = comm_websocket_adapter(comm);\n\n function ondownload(figure, _format) {\n window.open(figure.canvas.toDataURL());\n }\n\n var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n // web socket which is closed, not our websocket->open comm proxy.\n ws_proxy.onopen();\n\n fig.parent_element = element;\n fig.cell_info = mpl.find_output_cell(\"
\");\n if (!fig.cell_info) {\n console.error('Failed to find cell for figure', id, fig);\n return;\n }\n fig.cell_info[0].output_area.element.on(\n 'cleared',\n { fig: fig },\n fig._remove_fig_handler\n );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n var width = fig.canvas.width / fig.ratio;\n fig.cell_info[0].output_area.element.off(\n 'cleared',\n fig._remove_fig_handler\n );\n fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n // Update the output cell to use the data from the current canvas.\n fig.push_to_output();\n var dataURL = fig.canvas.toDataURL();\n // Re-enable the keyboard manager in IPython - without this line, in FF,\n // the notebook keyboard shortcuts fail.\n IPython.keyboard_manager.enable();\n fig.parent_element.innerHTML =\n '';\n fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n // Turn the data on the canvas into data in the output cell.\n var width = this.canvas.width / this.ratio;\n var dataURL = this.canvas.toDataURL();\n this.cell_info[1]['text/html'] =\n '';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Tell IPython that the notebook contents must change.\n IPython.notebook.set_dirty(true);\n this.send_message('ack', {});\n var fig = this;\n // Wait a second, then push the new image to the DOM so\n // that it is saved nicely (might be nice to debounce this).\n setTimeout(function () {\n fig.push_to_output();\n }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'btn-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n var button;\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n continue;\n }\n\n button = fig.buttons[name] = document.createElement('button');\n button.classList = 'btn btn-default';\n button.href = '#';\n button.title = name;\n button.innerHTML = '';\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n // Add the status bar.\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message pull-right';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n\n // Add the close button to the window.\n var buttongrp = document.createElement('div');\n buttongrp.classList = 'btn-group inline pull-right';\n button = document.createElement('button');\n button.classList = 'btn btn-mini btn-primary';\n button.href = '#';\n button.title = 'Stop Interaction';\n button.innerHTML = '';\n button.addEventListener('click', function (_evt) {\n fig.handle_close(fig, {});\n });\n button.addEventListener(\n 'mouseover',\n on_mouseover_closure('Stop Interaction')\n );\n buttongrp.appendChild(button);\n var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n var fig = event.data.fig;\n if (event.target !== this) {\n // Ignore bubbled events from children.\n return;\n }\n fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n // this is important to make the div 'focusable\n el.setAttribute('tabindex', 0);\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n } else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n // Check for shift+enter\n if (event.shiftKey && event.which === 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i = 0; i < ncells; i++) {\n var cell = cells[i];\n if (cell.cell_type === 'code') {\n for (var j = 0; j < cell.output_area.outputs.length; j++) {\n var data = cell.output_area.outputs[j];\n if (data.data) {\n // IPython >= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] === html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n IPython.notebook.kernel.comm_manager.register_target(\n 'matplotlib',\n mpl.mpl_figure_comm\n );\n}\n", "text/plain": [ "" ] @@ -438,7 +438,7 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ "" @@ -453,7 +453,7 @@ "Text(0, 0.5, 'Eigenvale')" ] }, - "execution_count": 28, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -482,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -491,12 +491,12 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n if (typeof WebSocket !== 'undefined') {\n return WebSocket;\n } else if (typeof MozWebSocket !== 'undefined') {\n return MozWebSocket;\n } else {\n alert(\n 'Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.'\n );\n }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = this.ws.binaryType !== undefined;\n\n if (!this.supports_binary) {\n var warnings = document.getElementById('mpl-warnings');\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent =\n 'This browser does not support binary websocket messages. ' +\n 'Performance may be slow.';\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = document.createElement('div');\n this.root.setAttribute('style', 'display: inline-block');\n this._root_extra_style(this.root);\n\n parent_element.appendChild(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message('supports_binary', { value: fig.supports_binary });\n fig.send_message('send_image_mode', {});\n if (fig.ratio !== 1) {\n fig.send_message('set_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\n }\n fig.send_message('refresh', {});\n };\n\n this.imageObj.onload = function () {\n if (fig.image_mode === 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function () {\n fig.ws.close();\n };\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n var titlebar = document.createElement('div');\n titlebar.classList =\n 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n var titletext = document.createElement('div');\n titletext.classList = 'ui-dialog-title';\n titletext.setAttribute(\n 'style',\n 'width: 100%; text-align: center; padding: 3px;'\n );\n titlebar.appendChild(titletext);\n this.root.appendChild(titlebar);\n this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n var fig = this;\n\n var canvas_div = (this.canvas_div = document.createElement('div'));\n canvas_div.setAttribute('tabindex', '0');\n canvas_div.setAttribute(\n 'style',\n 'border: 1px solid #ddd;' +\n 'box-sizing: content-box;' +\n 'clear: both;' +\n 'min-height: 1px;' +\n 'min-width: 1px;' +\n 'outline: 0;' +\n 'overflow: hidden;' +\n 'position: relative;' +\n 'resize: both;' +\n 'z-index: 2;'\n );\n\n function on_keyboard_event_closure(name) {\n return function (event) {\n return fig.key_event(event, name);\n };\n }\n\n canvas_div.addEventListener(\n 'keydown',\n on_keyboard_event_closure('key_press')\n );\n canvas_div.addEventListener(\n 'keyup',\n on_keyboard_event_closure('key_release')\n );\n\n this._canvas_extra_style(canvas_div);\n this.root.appendChild(canvas_div);\n\n var canvas = (this.canvas = document.createElement('canvas'));\n canvas.classList.add('mpl-canvas');\n canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'pointer-events: none;' +\n 'position: relative;' +\n 'z-index: 0;'\n );\n\n this.context = canvas.getContext('2d');\n\n var backingStore =\n this.context.backingStorePixelRatio ||\n this.context.webkitBackingStorePixelRatio ||\n this.context.mozBackingStorePixelRatio ||\n this.context.msBackingStorePixelRatio ||\n this.context.oBackingStorePixelRatio ||\n this.context.backingStorePixelRatio ||\n 1;\n\n this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n 'canvas'\n ));\n rubberband_canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'left: 0;' +\n 'pointer-events: none;' +\n 'position: absolute;' +\n 'top: 0;' +\n 'z-index: 1;'\n );\n\n // Apply a ponyfill if ResizeObserver is not implemented by browser.\n if (this.ResizeObserver === undefined) {\n if (window.ResizeObserver !== undefined) {\n this.ResizeObserver = window.ResizeObserver;\n } else {\n var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n this.ResizeObserver = obs.ResizeObserver;\n }\n }\n\n this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n // There's no need to resize if the WebSocket is not connected:\n // - If it is still connecting, then we will get an initial resize from\n // Python once it connects.\n // - If it has disconnected, then resizing will clear the canvas and\n // never get anything back to refill it, so better to not resize and\n // keep something visible.\n if (fig.ws.readyState != 1) {\n return;\n }\n var nentries = entries.length;\n for (var i = 0; i < nentries; i++) {\n var entry = entries[i];\n var width, height;\n if (entry.contentBoxSize) {\n if (entry.contentBoxSize instanceof Array) {\n // Chrome 84 implements new version of spec.\n width = entry.contentBoxSize[0].inlineSize;\n height = entry.contentBoxSize[0].blockSize;\n } else {\n // Firefox implements old version of spec.\n width = entry.contentBoxSize.inlineSize;\n height = entry.contentBoxSize.blockSize;\n }\n } else {\n // Chrome <84 implements even older version of spec.\n width = entry.contentRect.width;\n height = entry.contentRect.height;\n }\n\n // Keep the size of the canvas and rubber band canvas in sync with\n // the canvas container.\n if (entry.devicePixelContentBoxSize) {\n // Chrome 84 implements new version of spec.\n canvas.setAttribute(\n 'width',\n entry.devicePixelContentBoxSize[0].inlineSize\n );\n canvas.setAttribute(\n 'height',\n entry.devicePixelContentBoxSize[0].blockSize\n );\n } else {\n canvas.setAttribute('width', width * fig.ratio);\n canvas.setAttribute('height', height * fig.ratio);\n }\n /* This rescales the canvas back to display pixels, so that it\n * appears correct on HiDPI screens. */\n canvas.style.width = width + 'px';\n canvas.style.height = height + 'px';\n\n rubberband_canvas.setAttribute('width', width);\n rubberband_canvas.setAttribute('height', height);\n\n // And update the size in Python. We ignore the initial 0/0 size\n // that occurs as the element is placed into the DOM, which should\n // otherwise not happen due to the minimum size styling.\n if (width != 0 && height != 0) {\n fig.request_resize(width, height);\n }\n }\n });\n this.resizeObserverInstance.observe(canvas_div);\n\n function on_mouse_event_closure(name) {\n /* User Agent sniffing is bad, but WebKit is busted:\n * https://bugs.webkit.org/show_bug.cgi?id=144526\n * https://bugs.webkit.org/show_bug.cgi?id=181818\n * The worst that happens here is that they get an extra browser\n * selection when dragging, if this check fails to catch them.\n */\n var UA = navigator.userAgent;\n var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n if(isWebKit) {\n return function (event) {\n /* This prevents the web browser from automatically changing to\n * the text insertion cursor when the button is pressed. We\n * want to control all of the cursor setting manually through\n * the 'cursor' event from matplotlib */\n event.preventDefault()\n return fig.mouse_event(event, name);\n };\n } else {\n return function (event) {\n return fig.mouse_event(event, name);\n };\n }\n }\n\n canvas_div.addEventListener(\n 'mousedown',\n on_mouse_event_closure('button_press')\n );\n canvas_div.addEventListener(\n 'mouseup',\n on_mouse_event_closure('button_release')\n );\n canvas_div.addEventListener(\n 'dblclick',\n on_mouse_event_closure('dblclick')\n );\n // Throttle sequential mouse events to 1 every 20ms.\n canvas_div.addEventListener(\n 'mousemove',\n on_mouse_event_closure('motion_notify')\n );\n\n canvas_div.addEventListener(\n 'mouseenter',\n on_mouse_event_closure('figure_enter')\n );\n canvas_div.addEventListener(\n 'mouseleave',\n on_mouse_event_closure('figure_leave')\n );\n\n canvas_div.addEventListener('wheel', function (event) {\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n on_mouse_event_closure('scroll')(event);\n });\n\n canvas_div.appendChild(canvas);\n canvas_div.appendChild(rubberband_canvas);\n\n this.rubberband_context = rubberband_canvas.getContext('2d');\n this.rubberband_context.strokeStyle = '#000000';\n\n this._resize_canvas = function (width, height, forward) {\n if (forward) {\n canvas_div.style.width = width + 'px';\n canvas_div.style.height = height + 'px';\n }\n };\n\n // Disable right mouse context menu.\n canvas_div.addEventListener('contextmenu', function (_e) {\n event.preventDefault();\n return false;\n });\n\n function set_focus() {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'mpl-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n continue;\n }\n\n var button = (fig.buttons[name] = document.createElement('button'));\n button.classList = 'mpl-widget';\n button.setAttribute('role', 'button');\n button.setAttribute('aria-disabled', 'false');\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n var icon_img = document.createElement('img');\n icon_img.src = '_images/' + image + '.png';\n icon_img.srcset = '_images/' + image + '_large.png 2x';\n icon_img.alt = tooltip;\n button.appendChild(icon_img);\n\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n var fmt_picker = document.createElement('select');\n fmt_picker.classList = 'mpl-widget';\n toolbar.appendChild(fmt_picker);\n this.format_dropdown = fmt_picker;\n\n for (var ind in mpl.extensions) {\n var fmt = mpl.extensions[ind];\n var option = document.createElement('option');\n option.selected = fmt === mpl.default_extension;\n option.innerHTML = fmt;\n fmt_picker.appendChild(option);\n }\n\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n // which will in turn request a refresh of the image.\n this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n properties['type'] = type;\n properties['figure_id'] = this.id;\n this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n if (!this.waiting) {\n this.waiting = true;\n this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n var format_dropdown = fig.format_dropdown;\n var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n var size = msg['size'];\n if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n fig._resize_canvas(size[0], size[1], msg['forward']);\n fig.send_message('refresh', {});\n }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n var x0 = msg['x0'] / fig.ratio;\n var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n var x1 = msg['x1'] / fig.ratio;\n var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n x0 = Math.floor(x0) + 0.5;\n y0 = Math.floor(y0) + 0.5;\n x1 = Math.floor(x1) + 0.5;\n y1 = Math.floor(y1) + 0.5;\n var min_x = Math.min(x0, x1);\n var min_y = Math.min(y0, y1);\n var width = Math.abs(x1 - x0);\n var height = Math.abs(y1 - y0);\n\n fig.rubberband_context.clearRect(\n 0,\n 0,\n fig.canvas.width / fig.ratio,\n fig.canvas.height / fig.ratio\n );\n\n fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n for (var key in msg) {\n if (!(key in fig.buttons)) {\n continue;\n }\n fig.buttons[key].disabled = !msg[key];\n fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n if (msg['mode'] === 'PAN') {\n fig.buttons['Pan'].classList.add('active');\n fig.buttons['Zoom'].classList.remove('active');\n } else if (msg['mode'] === 'ZOOM') {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.add('active');\n } else {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.remove('active');\n }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Called whenever the canvas gets updated.\n this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n return function socket_on_message(evt) {\n if (evt.data instanceof Blob) {\n var img = evt.data;\n if (img.type !== 'image/png') {\n /* FIXME: We get \"Resource interpreted as Image but\n * transferred with MIME type text/plain:\" errors on\n * Chrome. But how to set the MIME type? It doesn't seem\n * to be part of the websocket stream */\n img.type = 'image/png';\n }\n\n /* Free the memory for the previous frames */\n if (fig.imageObj.src) {\n (window.URL || window.webkitURL).revokeObjectURL(\n fig.imageObj.src\n );\n }\n\n fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n img\n );\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n } else if (\n typeof evt.data === 'string' &&\n evt.data.slice(0, 21) === 'data:image/png;base64'\n ) {\n fig.imageObj.src = evt.data;\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n }\n\n var msg = JSON.parse(evt.data);\n var msg_type = msg['type'];\n\n // Call the \"handle_{type}\" callback, which takes\n // the figure and JSON message as its only arguments.\n try {\n var callback = fig['handle_' + msg_type];\n } catch (e) {\n console.log(\n \"No handler for the '\" + msg_type + \"' message type: \",\n msg\n );\n return;\n }\n\n if (callback) {\n try {\n // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n callback(fig, msg);\n } catch (e) {\n console.log(\n \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n e,\n e.stack,\n msg\n );\n }\n }\n };\n};\n\nfunction getModifiers(event) {\n var mods = [];\n if (event.ctrlKey) {\n mods.push('ctrl');\n }\n if (event.altKey) {\n mods.push('alt');\n }\n if (event.shiftKey) {\n mods.push('shift');\n }\n if (event.metaKey) {\n mods.push('meta');\n }\n return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n return Object.keys(original).reduce(function (obj, key) {\n if (typeof original[key] !== 'object') {\n obj[key] = original[key];\n }\n return obj;\n }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n if (name === 'button_press') {\n this.canvas.focus();\n this.canvas_div.focus();\n }\n\n // from https://stackoverflow.com/q/1114465\n var boundingRect = this.canvas.getBoundingClientRect();\n var x = (event.clientX - boundingRect.left) * this.ratio;\n var y = (event.clientY - boundingRect.top) * this.ratio;\n\n this.send_message(name, {\n x: x,\n y: y,\n button: event.button,\n step: event.step,\n modifiers: getModifiers(event),\n guiEvent: simpleKeys(event),\n });\n\n return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n // Prevent repeat events\n if (name === 'key_press') {\n if (event.key === this._key) {\n return;\n } else {\n this._key = event.key;\n }\n }\n if (name === 'key_release') {\n this._key = null;\n }\n\n var value = '';\n if (event.ctrlKey && event.key !== 'Control') {\n value += 'ctrl+';\n }\n else if (event.altKey && event.key !== 'Alt') {\n value += 'alt+';\n }\n else if (event.shiftKey && event.key !== 'Shift') {\n value += 'shift+';\n }\n\n value += 'k' + event.key;\n\n this._key_event_extra(event, name);\n\n this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n if (name === 'download') {\n this.handle_save(this, null);\n } else {\n this.send_message('toolbar_button', { name: name });\n }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n // Create a \"websocket\"-like object which calls the given IPython comm\n // object with the appropriate methods. Currently this is a non binary\n // socket, so there is still some room for performance tuning.\n var ws = {};\n\n ws.binaryType = comm.kernel.ws.binaryType;\n ws.readyState = comm.kernel.ws.readyState;\n function updateReadyState(_event) {\n if (comm.kernel.ws) {\n ws.readyState = comm.kernel.ws.readyState;\n } else {\n ws.readyState = 3; // Closed state.\n }\n }\n comm.kernel.ws.addEventListener('open', updateReadyState);\n comm.kernel.ws.addEventListener('close', updateReadyState);\n comm.kernel.ws.addEventListener('error', updateReadyState);\n\n ws.close = function () {\n comm.close();\n };\n ws.send = function (m) {\n //console.log('sending', m);\n comm.send(m);\n };\n // Register the callback with on_msg.\n comm.on_msg(function (msg) {\n //console.log('receiving', msg['content']['data'], msg);\n var data = msg['content']['data'];\n if (data['blob'] !== undefined) {\n data = {\n data: new Blob(msg['buffers'], { type: data['blob'] }),\n };\n }\n // Pass the mpl event to the overridden (by mpl) onmessage function.\n ws.onmessage(data);\n });\n return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n // This is the function which gets called when the mpl process\n // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n var id = msg.content.data.id;\n // Get hold of the div created by the display call when the Comm\n // socket was opened in Python.\n var element = document.getElementById(id);\n var ws_proxy = comm_websocket_adapter(comm);\n\n function ondownload(figure, _format) {\n window.open(figure.canvas.toDataURL());\n }\n\n var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n // web socket which is closed, not our websocket->open comm proxy.\n ws_proxy.onopen();\n\n fig.parent_element = element;\n fig.cell_info = mpl.find_output_cell(\"
\");\n if (!fig.cell_info) {\n console.error('Failed to find cell for figure', id, fig);\n return;\n }\n fig.cell_info[0].output_area.element.on(\n 'cleared',\n { fig: fig },\n fig._remove_fig_handler\n );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n var width = fig.canvas.width / fig.ratio;\n fig.cell_info[0].output_area.element.off(\n 'cleared',\n fig._remove_fig_handler\n );\n fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n // Update the output cell to use the data from the current canvas.\n fig.push_to_output();\n var dataURL = fig.canvas.toDataURL();\n // Re-enable the keyboard manager in IPython - without this line, in FF,\n // the notebook keyboard shortcuts fail.\n IPython.keyboard_manager.enable();\n fig.parent_element.innerHTML =\n '';\n fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n // Turn the data on the canvas into data in the output cell.\n var width = this.canvas.width / this.ratio;\n var dataURL = this.canvas.toDataURL();\n this.cell_info[1]['text/html'] =\n '';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Tell IPython that the notebook contents must change.\n IPython.notebook.set_dirty(true);\n this.send_message('ack', {});\n var fig = this;\n // Wait a second, then push the new image to the DOM so\n // that it is saved nicely (might be nice to debounce this).\n setTimeout(function () {\n fig.push_to_output();\n }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'btn-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n var button;\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n continue;\n }\n\n button = fig.buttons[name] = document.createElement('button');\n button.classList = 'btn btn-default';\n button.href = '#';\n button.title = name;\n button.innerHTML = '';\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n // Add the status bar.\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message pull-right';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n\n // Add the close button to the window.\n var buttongrp = document.createElement('div');\n buttongrp.classList = 'btn-group inline pull-right';\n button = document.createElement('button');\n button.classList = 'btn btn-mini btn-primary';\n button.href = '#';\n button.title = 'Stop Interaction';\n button.innerHTML = '';\n button.addEventListener('click', function (_evt) {\n fig.handle_close(fig, {});\n });\n button.addEventListener(\n 'mouseover',\n on_mouseover_closure('Stop Interaction')\n );\n buttongrp.appendChild(button);\n var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n var fig = event.data.fig;\n if (event.target !== this) {\n // Ignore bubbled events from children.\n return;\n }\n fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n // this is important to make the div 'focusable\n el.setAttribute('tabindex', 0);\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n } else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n // Check for shift+enter\n if (event.shiftKey && event.which === 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i = 0; i < ncells; i++) {\n var cell = cells[i];\n if (cell.cell_type === 'code') {\n for (var j = 0; j < cell.output_area.outputs.length; j++) {\n var data = cell.output_area.outputs[j];\n if (data.data) {\n // IPython >= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] === html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n IPython.notebook.kernel.comm_manager.register_target(\n 'matplotlib',\n mpl.mpl_figure_comm\n );\n}\n", + "application/javascript": "/* Put everything inside the global mpl namespace */\n/* global mpl */\nwindow.mpl = {};\n\nmpl.get_websocket_type = function () {\n if (typeof WebSocket !== 'undefined') {\n return WebSocket;\n } else if (typeof MozWebSocket !== 'undefined') {\n return MozWebSocket;\n } else {\n alert(\n 'Your browser does not have WebSocket support. ' +\n 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n 'Firefox 4 and 5 are also supported but you ' +\n 'have to enable WebSockets in about:config.'\n );\n }\n};\n\nmpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n this.id = figure_id;\n\n this.ws = websocket;\n\n this.supports_binary = this.ws.binaryType !== undefined;\n\n if (!this.supports_binary) {\n var warnings = document.getElementById('mpl-warnings');\n if (warnings) {\n warnings.style.display = 'block';\n warnings.textContent =\n 'This browser does not support binary websocket messages. ' +\n 'Performance may be slow.';\n }\n }\n\n this.imageObj = new Image();\n\n this.context = undefined;\n this.message = undefined;\n this.canvas = undefined;\n this.rubberband_canvas = undefined;\n this.rubberband_context = undefined;\n this.format_dropdown = undefined;\n\n this.image_mode = 'full';\n\n this.root = document.createElement('div');\n this.root.setAttribute('style', 'display: inline-block');\n this._root_extra_style(this.root);\n\n parent_element.appendChild(this.root);\n\n this._init_header(this);\n this._init_canvas(this);\n this._init_toolbar(this);\n\n var fig = this;\n\n this.waiting = false;\n\n this.ws.onopen = function () {\n fig.send_message('supports_binary', { value: fig.supports_binary });\n fig.send_message('send_image_mode', {});\n if (fig.ratio !== 1) {\n fig.send_message('set_device_pixel_ratio', {\n device_pixel_ratio: fig.ratio,\n });\n }\n fig.send_message('refresh', {});\n };\n\n this.imageObj.onload = function () {\n if (fig.image_mode === 'full') {\n // Full images could contain transparency (where diff images\n // almost always do), so we need to clear the canvas so that\n // there is no ghosting.\n fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n }\n fig.context.drawImage(fig.imageObj, 0, 0);\n };\n\n this.imageObj.onunload = function () {\n fig.ws.close();\n };\n\n this.ws.onmessage = this._make_on_message_function(this);\n\n this.ondownload = ondownload;\n};\n\nmpl.figure.prototype._init_header = function () {\n var titlebar = document.createElement('div');\n titlebar.classList =\n 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n var titletext = document.createElement('div');\n titletext.classList = 'ui-dialog-title';\n titletext.setAttribute(\n 'style',\n 'width: 100%; text-align: center; padding: 3px;'\n );\n titlebar.appendChild(titletext);\n this.root.appendChild(titlebar);\n this.header = titletext;\n};\n\nmpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n\nmpl.figure.prototype._init_canvas = function () {\n var fig = this;\n\n var canvas_div = (this.canvas_div = document.createElement('div'));\n canvas_div.setAttribute('tabindex', '0');\n canvas_div.setAttribute(\n 'style',\n 'border: 1px solid #ddd;' +\n 'box-sizing: content-box;' +\n 'clear: both;' +\n 'min-height: 1px;' +\n 'min-width: 1px;' +\n 'outline: 0;' +\n 'overflow: hidden;' +\n 'position: relative;' +\n 'resize: both;' +\n 'z-index: 2;'\n );\n\n function on_keyboard_event_closure(name) {\n return function (event) {\n return fig.key_event(event, name);\n };\n }\n\n canvas_div.addEventListener(\n 'keydown',\n on_keyboard_event_closure('key_press')\n );\n canvas_div.addEventListener(\n 'keyup',\n on_keyboard_event_closure('key_release')\n );\n\n this._canvas_extra_style(canvas_div);\n this.root.appendChild(canvas_div);\n\n var canvas = (this.canvas = document.createElement('canvas'));\n canvas.classList.add('mpl-canvas');\n canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'pointer-events: none;' +\n 'position: relative;' +\n 'z-index: 0;'\n );\n\n this.context = canvas.getContext('2d');\n\n var backingStore =\n this.context.backingStorePixelRatio ||\n this.context.webkitBackingStorePixelRatio ||\n this.context.mozBackingStorePixelRatio ||\n this.context.msBackingStorePixelRatio ||\n this.context.oBackingStorePixelRatio ||\n this.context.backingStorePixelRatio ||\n 1;\n\n this.ratio = (window.devicePixelRatio || 1) / backingStore;\n\n var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n 'canvas'\n ));\n rubberband_canvas.setAttribute(\n 'style',\n 'box-sizing: content-box;' +\n 'left: 0;' +\n 'pointer-events: none;' +\n 'position: absolute;' +\n 'top: 0;' +\n 'z-index: 1;'\n );\n\n // Apply a ponyfill if ResizeObserver is not implemented by browser.\n if (this.ResizeObserver === undefined) {\n if (window.ResizeObserver !== undefined) {\n this.ResizeObserver = window.ResizeObserver;\n } else {\n var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n this.ResizeObserver = obs.ResizeObserver;\n }\n }\n\n this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n // There's no need to resize if the WebSocket is not connected:\n // - If it is still connecting, then we will get an initial resize from\n // Python once it connects.\n // - If it has disconnected, then resizing will clear the canvas and\n // never get anything back to refill it, so better to not resize and\n // keep something visible.\n if (fig.ws.readyState != 1) {\n return;\n }\n var nentries = entries.length;\n for (var i = 0; i < nentries; i++) {\n var entry = entries[i];\n var width, height;\n if (entry.contentBoxSize) {\n if (entry.contentBoxSize instanceof Array) {\n // Chrome 84 implements new version of spec.\n width = entry.contentBoxSize[0].inlineSize;\n height = entry.contentBoxSize[0].blockSize;\n } else {\n // Firefox implements old version of spec.\n width = entry.contentBoxSize.inlineSize;\n height = entry.contentBoxSize.blockSize;\n }\n } else {\n // Chrome <84 implements even older version of spec.\n width = entry.contentRect.width;\n height = entry.contentRect.height;\n }\n\n // Keep the size of the canvas and rubber band canvas in sync with\n // the canvas container.\n if (entry.devicePixelContentBoxSize) {\n // Chrome 84 implements new version of spec.\n canvas.setAttribute(\n 'width',\n entry.devicePixelContentBoxSize[0].inlineSize\n );\n canvas.setAttribute(\n 'height',\n entry.devicePixelContentBoxSize[0].blockSize\n );\n } else {\n canvas.setAttribute('width', width * fig.ratio);\n canvas.setAttribute('height', height * fig.ratio);\n }\n /* This rescales the canvas back to display pixels, so that it\n * appears correct on HiDPI screens. */\n canvas.style.width = width + 'px';\n canvas.style.height = height + 'px';\n\n rubberband_canvas.setAttribute('width', width);\n rubberband_canvas.setAttribute('height', height);\n\n // And update the size in Python. We ignore the initial 0/0 size\n // that occurs as the element is placed into the DOM, which should\n // otherwise not happen due to the minimum size styling.\n if (width != 0 && height != 0) {\n fig.request_resize(width, height);\n }\n }\n });\n this.resizeObserverInstance.observe(canvas_div);\n\n function on_mouse_event_closure(name) {\n /* User Agent sniffing is bad, but WebKit is busted:\n * https://bugs.webkit.org/show_bug.cgi?id=144526\n * https://bugs.webkit.org/show_bug.cgi?id=181818\n * The worst that happens here is that they get an extra browser\n * selection when dragging, if this check fails to catch them.\n */\n var UA = navigator.userAgent;\n var isWebKit = /AppleWebKit/.test(UA) && !/Chrome/.test(UA);\n if(isWebKit) {\n return function (event) {\n /* This prevents the web browser from automatically changing to\n * the text insertion cursor when the button is pressed. We\n * want to control all of the cursor setting manually through\n * the 'cursor' event from matplotlib */\n event.preventDefault()\n return fig.mouse_event(event, name);\n };\n } else {\n return function (event) {\n return fig.mouse_event(event, name);\n };\n }\n }\n\n canvas_div.addEventListener(\n 'mousedown',\n on_mouse_event_closure('button_press')\n );\n canvas_div.addEventListener(\n 'mouseup',\n on_mouse_event_closure('button_release')\n );\n canvas_div.addEventListener(\n 'dblclick',\n on_mouse_event_closure('dblclick')\n );\n // Throttle sequential mouse events to 1 every 20ms.\n canvas_div.addEventListener(\n 'mousemove',\n on_mouse_event_closure('motion_notify')\n );\n\n canvas_div.addEventListener(\n 'mouseenter',\n on_mouse_event_closure('figure_enter')\n );\n canvas_div.addEventListener(\n 'mouseleave',\n on_mouse_event_closure('figure_leave')\n );\n\n canvas_div.addEventListener('wheel', function (event) {\n if (event.deltaY < 0) {\n event.step = 1;\n } else {\n event.step = -1;\n }\n on_mouse_event_closure('scroll')(event);\n });\n\n canvas_div.appendChild(canvas);\n canvas_div.appendChild(rubberband_canvas);\n\n this.rubberband_context = rubberband_canvas.getContext('2d');\n this.rubberband_context.strokeStyle = '#000000';\n\n this._resize_canvas = function (width, height, forward) {\n if (forward) {\n canvas_div.style.width = width + 'px';\n canvas_div.style.height = height + 'px';\n }\n };\n\n // Disable right mouse context menu.\n canvas_div.addEventListener('contextmenu', function (_e) {\n event.preventDefault();\n return false;\n });\n\n function set_focus() {\n canvas.focus();\n canvas_div.focus();\n }\n\n window.setTimeout(set_focus, 100);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'mpl-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'mpl-button-group';\n continue;\n }\n\n var button = (fig.buttons[name] = document.createElement('button'));\n button.classList = 'mpl-widget';\n button.setAttribute('role', 'button');\n button.setAttribute('aria-disabled', 'false');\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n\n var icon_img = document.createElement('img');\n icon_img.src = '_images/' + image + '.png';\n icon_img.srcset = '_images/' + image + '_large.png 2x';\n icon_img.alt = tooltip;\n button.appendChild(icon_img);\n\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n var fmt_picker = document.createElement('select');\n fmt_picker.classList = 'mpl-widget';\n toolbar.appendChild(fmt_picker);\n this.format_dropdown = fmt_picker;\n\n for (var ind in mpl.extensions) {\n var fmt = mpl.extensions[ind];\n var option = document.createElement('option');\n option.selected = fmt === mpl.default_extension;\n option.innerHTML = fmt;\n fmt_picker.appendChild(option);\n }\n\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n};\n\nmpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n // which will in turn request a refresh of the image.\n this.send_message('resize', { width: x_pixels, height: y_pixels });\n};\n\nmpl.figure.prototype.send_message = function (type, properties) {\n properties['type'] = type;\n properties['figure_id'] = this.id;\n this.ws.send(JSON.stringify(properties));\n};\n\nmpl.figure.prototype.send_draw_message = function () {\n if (!this.waiting) {\n this.waiting = true;\n this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n var format_dropdown = fig.format_dropdown;\n var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n fig.ondownload(fig, format);\n};\n\nmpl.figure.prototype.handle_resize = function (fig, msg) {\n var size = msg['size'];\n if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n fig._resize_canvas(size[0], size[1], msg['forward']);\n fig.send_message('refresh', {});\n }\n};\n\nmpl.figure.prototype.handle_rubberband = function (fig, msg) {\n var x0 = msg['x0'] / fig.ratio;\n var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n var x1 = msg['x1'] / fig.ratio;\n var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n x0 = Math.floor(x0) + 0.5;\n y0 = Math.floor(y0) + 0.5;\n x1 = Math.floor(x1) + 0.5;\n y1 = Math.floor(y1) + 0.5;\n var min_x = Math.min(x0, x1);\n var min_y = Math.min(y0, y1);\n var width = Math.abs(x1 - x0);\n var height = Math.abs(y1 - y0);\n\n fig.rubberband_context.clearRect(\n 0,\n 0,\n fig.canvas.width / fig.ratio,\n fig.canvas.height / fig.ratio\n );\n\n fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n};\n\nmpl.figure.prototype.handle_figure_label = function (fig, msg) {\n // Updates the figure title.\n fig.header.textContent = msg['label'];\n};\n\nmpl.figure.prototype.handle_cursor = function (fig, msg) {\n fig.canvas_div.style.cursor = msg['cursor'];\n};\n\nmpl.figure.prototype.handle_message = function (fig, msg) {\n fig.message.textContent = msg['message'];\n};\n\nmpl.figure.prototype.handle_draw = function (fig, _msg) {\n // Request the server to send over a new figure.\n fig.send_draw_message();\n};\n\nmpl.figure.prototype.handle_image_mode = function (fig, msg) {\n fig.image_mode = msg['mode'];\n};\n\nmpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n for (var key in msg) {\n if (!(key in fig.buttons)) {\n continue;\n }\n fig.buttons[key].disabled = !msg[key];\n fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n }\n};\n\nmpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n if (msg['mode'] === 'PAN') {\n fig.buttons['Pan'].classList.add('active');\n fig.buttons['Zoom'].classList.remove('active');\n } else if (msg['mode'] === 'ZOOM') {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.add('active');\n } else {\n fig.buttons['Pan'].classList.remove('active');\n fig.buttons['Zoom'].classList.remove('active');\n }\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Called whenever the canvas gets updated.\n this.send_message('ack', {});\n};\n\n// A function to construct a web socket function for onmessage handling.\n// Called in the figure constructor.\nmpl.figure.prototype._make_on_message_function = function (fig) {\n return function socket_on_message(evt) {\n if (evt.data instanceof Blob) {\n var img = evt.data;\n if (img.type !== 'image/png') {\n /* FIXME: We get \"Resource interpreted as Image but\n * transferred with MIME type text/plain:\" errors on\n * Chrome. But how to set the MIME type? It doesn't seem\n * to be part of the websocket stream */\n img.type = 'image/png';\n }\n\n /* Free the memory for the previous frames */\n if (fig.imageObj.src) {\n (window.URL || window.webkitURL).revokeObjectURL(\n fig.imageObj.src\n );\n }\n\n fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n img\n );\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n } else if (\n typeof evt.data === 'string' &&\n evt.data.slice(0, 21) === 'data:image/png;base64'\n ) {\n fig.imageObj.src = evt.data;\n fig.updated_canvas_event();\n fig.waiting = false;\n return;\n }\n\n var msg = JSON.parse(evt.data);\n var msg_type = msg['type'];\n\n // Call the \"handle_{type}\" callback, which takes\n // the figure and JSON message as its only arguments.\n try {\n var callback = fig['handle_' + msg_type];\n } catch (e) {\n console.log(\n \"No handler for the '\" + msg_type + \"' message type: \",\n msg\n );\n return;\n }\n\n if (callback) {\n try {\n // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n callback(fig, msg);\n } catch (e) {\n console.log(\n \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n e,\n e.stack,\n msg\n );\n }\n }\n };\n};\n\nfunction getModifiers(event) {\n var mods = [];\n if (event.ctrlKey) {\n mods.push('ctrl');\n }\n if (event.altKey) {\n mods.push('alt');\n }\n if (event.shiftKey) {\n mods.push('shift');\n }\n if (event.metaKey) {\n mods.push('meta');\n }\n return mods;\n}\n\n/*\n * return a copy of an object with only non-object keys\n * we need this to avoid circular references\n * https://stackoverflow.com/a/24161582/3208463\n */\nfunction simpleKeys(original) {\n return Object.keys(original).reduce(function (obj, key) {\n if (typeof original[key] !== 'object') {\n obj[key] = original[key];\n }\n return obj;\n }, {});\n}\n\nmpl.figure.prototype.mouse_event = function (event, name) {\n if (name === 'button_press') {\n this.canvas.focus();\n this.canvas_div.focus();\n }\n\n // from https://stackoverflow.com/q/1114465\n var boundingRect = this.canvas.getBoundingClientRect();\n var x = (event.clientX - boundingRect.left) * this.ratio;\n var y = (event.clientY - boundingRect.top) * this.ratio;\n\n this.send_message(name, {\n x: x,\n y: y,\n button: event.button,\n step: event.step,\n buttons: event.buttons,\n modifiers: getModifiers(event),\n guiEvent: simpleKeys(event),\n });\n\n return false;\n};\n\nmpl.figure.prototype._key_event_extra = function (_event, _name) {\n // Handle any extra behaviour associated with a key event\n};\n\nmpl.figure.prototype.key_event = function (event, name) {\n // Prevent repeat events\n if (name === 'key_press') {\n if (event.key === this._key) {\n return;\n } else {\n this._key = event.key;\n }\n }\n if (name === 'key_release') {\n this._key = null;\n }\n\n var value = '';\n if (event.ctrlKey && event.key !== 'Control') {\n value += 'ctrl+';\n }\n else if (event.altKey && event.key !== 'Alt') {\n value += 'alt+';\n }\n else if (event.shiftKey && event.key !== 'Shift') {\n value += 'shift+';\n }\n\n value += 'k' + event.key;\n\n this._key_event_extra(event, name);\n\n this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n return false;\n};\n\nmpl.figure.prototype.toolbar_button_onclick = function (name) {\n if (name === 'download') {\n this.handle_save(this, null);\n } else {\n this.send_message('toolbar_button', { name: name });\n }\n};\n\nmpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n this.message.textContent = tooltip;\n};\n\n///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n// prettier-ignore\nvar _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\nmpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o\", \"download\"]];\n\nmpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\", \"webp\"];\n\nmpl.default_extension = \"png\";/* global mpl */\n\nvar comm_websocket_adapter = function (comm) {\n // Create a \"websocket\"-like object which calls the given IPython comm\n // object with the appropriate methods. Currently this is a non binary\n // socket, so there is still some room for performance tuning.\n var ws = {};\n\n ws.binaryType = comm.kernel.ws.binaryType;\n ws.readyState = comm.kernel.ws.readyState;\n function updateReadyState(_event) {\n if (comm.kernel.ws) {\n ws.readyState = comm.kernel.ws.readyState;\n } else {\n ws.readyState = 3; // Closed state.\n }\n }\n comm.kernel.ws.addEventListener('open', updateReadyState);\n comm.kernel.ws.addEventListener('close', updateReadyState);\n comm.kernel.ws.addEventListener('error', updateReadyState);\n\n ws.close = function () {\n comm.close();\n };\n ws.send = function (m) {\n //console.log('sending', m);\n comm.send(m);\n };\n // Register the callback with on_msg.\n comm.on_msg(function (msg) {\n //console.log('receiving', msg['content']['data'], msg);\n var data = msg['content']['data'];\n if (data['blob'] !== undefined) {\n data = {\n data: new Blob(msg['buffers'], { type: data['blob'] }),\n };\n }\n // Pass the mpl event to the overridden (by mpl) onmessage function.\n ws.onmessage(data);\n });\n return ws;\n};\n\nmpl.mpl_figure_comm = function (comm, msg) {\n // This is the function which gets called when the mpl process\n // starts-up an IPython Comm through the \"matplotlib\" channel.\n\n var id = msg.content.data.id;\n // Get hold of the div created by the display call when the Comm\n // socket was opened in Python.\n var element = document.getElementById(id);\n var ws_proxy = comm_websocket_adapter(comm);\n\n function ondownload(figure, _format) {\n window.open(figure.canvas.toDataURL());\n }\n\n var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n\n // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n // web socket which is closed, not our websocket->open comm proxy.\n ws_proxy.onopen();\n\n fig.parent_element = element;\n fig.cell_info = mpl.find_output_cell(\"
\");\n if (!fig.cell_info) {\n console.error('Failed to find cell for figure', id, fig);\n return;\n }\n fig.cell_info[0].output_area.element.on(\n 'cleared',\n { fig: fig },\n fig._remove_fig_handler\n );\n};\n\nmpl.figure.prototype.handle_close = function (fig, msg) {\n var width = fig.canvas.width / fig.ratio;\n fig.cell_info[0].output_area.element.off(\n 'cleared',\n fig._remove_fig_handler\n );\n fig.resizeObserverInstance.unobserve(fig.canvas_div);\n\n // Update the output cell to use the data from the current canvas.\n fig.push_to_output();\n var dataURL = fig.canvas.toDataURL();\n // Re-enable the keyboard manager in IPython - without this line, in FF,\n // the notebook keyboard shortcuts fail.\n IPython.keyboard_manager.enable();\n fig.parent_element.innerHTML =\n '';\n fig.close_ws(fig, msg);\n};\n\nmpl.figure.prototype.close_ws = function (fig, msg) {\n fig.send_message('closing', msg);\n // fig.ws.close()\n};\n\nmpl.figure.prototype.push_to_output = function (_remove_interactive) {\n // Turn the data on the canvas into data in the output cell.\n var width = this.canvas.width / this.ratio;\n var dataURL = this.canvas.toDataURL();\n this.cell_info[1]['text/html'] =\n '';\n};\n\nmpl.figure.prototype.updated_canvas_event = function () {\n // Tell IPython that the notebook contents must change.\n IPython.notebook.set_dirty(true);\n this.send_message('ack', {});\n var fig = this;\n // Wait a second, then push the new image to the DOM so\n // that it is saved nicely (might be nice to debounce this).\n setTimeout(function () {\n fig.push_to_output();\n }, 1000);\n};\n\nmpl.figure.prototype._init_toolbar = function () {\n var fig = this;\n\n var toolbar = document.createElement('div');\n toolbar.classList = 'btn-toolbar';\n this.root.appendChild(toolbar);\n\n function on_click_closure(name) {\n return function (_event) {\n return fig.toolbar_button_onclick(name);\n };\n }\n\n function on_mouseover_closure(tooltip) {\n return function (event) {\n if (!event.currentTarget.disabled) {\n return fig.toolbar_button_onmouseover(tooltip);\n }\n };\n }\n\n fig.buttons = {};\n var buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n var button;\n for (var toolbar_ind in mpl.toolbar_items) {\n var name = mpl.toolbar_items[toolbar_ind][0];\n var tooltip = mpl.toolbar_items[toolbar_ind][1];\n var image = mpl.toolbar_items[toolbar_ind][2];\n var method_name = mpl.toolbar_items[toolbar_ind][3];\n\n if (!name) {\n /* Instead of a spacer, we start a new button group. */\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n buttonGroup = document.createElement('div');\n buttonGroup.classList = 'btn-group';\n continue;\n }\n\n button = fig.buttons[name] = document.createElement('button');\n button.classList = 'btn btn-default';\n button.href = '#';\n button.title = name;\n button.innerHTML = '';\n button.addEventListener('click', on_click_closure(method_name));\n button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n buttonGroup.appendChild(button);\n }\n\n if (buttonGroup.hasChildNodes()) {\n toolbar.appendChild(buttonGroup);\n }\n\n // Add the status bar.\n var status_bar = document.createElement('span');\n status_bar.classList = 'mpl-message pull-right';\n toolbar.appendChild(status_bar);\n this.message = status_bar;\n\n // Add the close button to the window.\n var buttongrp = document.createElement('div');\n buttongrp.classList = 'btn-group inline pull-right';\n button = document.createElement('button');\n button.classList = 'btn btn-mini btn-primary';\n button.href = '#';\n button.title = 'Stop Interaction';\n button.innerHTML = '';\n button.addEventListener('click', function (_evt) {\n fig.handle_close(fig, {});\n });\n button.addEventListener(\n 'mouseover',\n on_mouseover_closure('Stop Interaction')\n );\n buttongrp.appendChild(button);\n var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n titlebar.insertBefore(buttongrp, titlebar.firstChild);\n};\n\nmpl.figure.prototype._remove_fig_handler = function (event) {\n var fig = event.data.fig;\n if (event.target !== this) {\n // Ignore bubbled events from children.\n return;\n }\n fig.close_ws(fig, {});\n};\n\nmpl.figure.prototype._root_extra_style = function (el) {\n el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n};\n\nmpl.figure.prototype._canvas_extra_style = function (el) {\n // this is important to make the div 'focusable\n el.setAttribute('tabindex', 0);\n // reach out to IPython and tell the keyboard manager to turn it's self\n // off when our div gets focus\n\n // location in version 3\n if (IPython.notebook.keyboard_manager) {\n IPython.notebook.keyboard_manager.register_events(el);\n } else {\n // location in version 2\n IPython.keyboard_manager.register_events(el);\n }\n};\n\nmpl.figure.prototype._key_event_extra = function (event, _name) {\n // Check for shift+enter\n if (event.shiftKey && event.which === 13) {\n this.canvas_div.blur();\n // select the cell after this one\n var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n IPython.notebook.select(index + 1);\n }\n};\n\nmpl.figure.prototype.handle_save = function (fig, _msg) {\n fig.ondownload(fig, null);\n};\n\nmpl.find_output_cell = function (html_output) {\n // Return the cell and output element which can be found *uniquely* in the notebook.\n // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n // IPython event is triggered only after the cells have been serialised, which for\n // our purposes (turning an active figure into a static one), is too late.\n var cells = IPython.notebook.get_cells();\n var ncells = cells.length;\n for (var i = 0; i < ncells; i++) {\n var cell = cells[i];\n if (cell.cell_type === 'code') {\n for (var j = 0; j < cell.output_area.outputs.length; j++) {\n var data = cell.output_area.outputs[j];\n if (data.data) {\n // IPython >= 3 moved mimebundle to data attribute of output\n data = data.data;\n }\n if (data['text/html'] === html_output) {\n return [cell, data, j];\n }\n }\n }\n }\n};\n\n// Register the function which deals with the matplotlib target/channel.\n// The kernel may be null if the page has been refreshed.\nif (IPython.notebook.kernel !== null) {\n IPython.notebook.kernel.comm_manager.register_target(\n 'matplotlib',\n mpl.mpl_figure_comm\n );\n}\n", "text/plain": [ "" ] @@ -507,7 +507,7 @@ { "data": { "text/html": [ - "
" + "
" ], "text/plain": [ "" @@ -520,7 +520,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/kssgarcia/Documents/SolidsPkg/SolidsPy/src/solidspy/postprocesor.py:121: UserWarning: The following kwargs were not used by contour: 'shading'\n", + "/home/kssgarcia/Documents/SolidsPkg/SolidsPy/src/solidspy/postprocesor.py:293: UserWarning: The following kwargs were not used by contour: 'shading'\n", " disp_plot(tri, field, levels, shading=\"gouraud\")\n" ] } @@ -539,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -601,7 +601,7 @@ ], "metadata": { "kernelspec": { - "display_name": "solids-test2", + "display_name": "solids-test", "language": "python", "name": "python3" }, @@ -615,7 +615,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.7" + "version": "3.12.8" }, "toc": { "base_numbering": 1, diff --git a/examples/membrane_vibration/membrane_vibration.py b/examples/membrane_vibration/membrane_vibration.py index 514d1c5..26ed834 100644 --- a/examples/membrane_vibration/membrane_vibration.py +++ b/examples/membrane_vibration/membrane_vibration.py @@ -103,15 +103,14 @@ def acoust_tri6(coord, params): mesh = meshio.read("square.msh") points = mesh.points cells = mesh.cells - tri6 = cells["triangle6"] - line3 = cells["line3"] + tri6 = next(cell for cell in cells if cell.type == "triangle6").data + line3 = next(cell for cell in cells if cell.type == "line3").data npts = points.shape[0] nels = tri6.shape[0] nodes = np.zeros((npts, 3)) nodes[:, 1:] = points[:, 0:2] - # Constraints line_nodes = list(set(line3.flatten())) cons = np.zeros((npts, 1), dtype=int) @@ -128,7 +127,7 @@ def acoust_tri6(coord, params): # Assembly - assem_op, bc_array, neq = ass.DME(cons, elements, + assem_op, bc_array, neq = ass.node2dof(cons, elements, ndof_node=1, ndof_el_max=6) stiff_mat, mass_mat = ass.assembler(elements, mats, nodes, neq, assem_op, uel=acoust_tri6) @@ -150,7 +149,6 @@ def acoust_tri6(coord, params): plt.ylabel("Eigenvale") # Visualization - sol = pos.complete_disp(bc_array, nodes, eigvecs[:, 0], ndof_node=1) pos.plot_node_field(sol[:, 0], nodes, elements) diff --git a/examples/simple_truss/simple_truss.ipynb b/examples/simple_truss/simple_truss.ipynb index 9478f68..51a23c5 100755 --- a/examples/simple_truss/simple_truss.ipynb +++ b/examples/simple_truss/simple_truss.ipynb @@ -370,8 +370,8 @@ " [0, 10*np.sqrt(3)/2, 0.0, 0, 0],\n", " [1, 0.0, 5.0, 0, 0],\n", " [2, 0.0, 0.0, 0, 0]])\n", - "DME , IBC , neq = ass.DME(nodes_uncon[:,-2:], eles)\n", - "KG_uncon = ass.assembler(eles, mats, nodes_uncon, neq, DME, sparse=False)\n", + "node2dof , IBC , neq = ass.node2dof(nodes_uncon[:,-2:], eles)\n", + "KG_uncon = ass.assembler(eles, mats, nodes_uncon, neq, node2dof, sparse=False)\n", "print(np.round(KG_uncon))" ] }, @@ -403,8 +403,8 @@ "outputs": [], "source": [ "# System assembly\n", - "DME , IBC , neq = ass.DME(nodes[:,-2:], eles)\n", - "stiff, mat = ass.assembler(eles, mats, nodes, neq, DME, sparse=False)\n", + "node2dof , IBC , neq = ass.node2dof(nodes[:,-2:], eles)\n", + "stiff, mat = ass.assembler(eles, mats, nodes, neq, node2dof, sparse=False)\n", "load_vec = ass.loadasem(loads, IBC, neq) # right-hand-side" ] }, diff --git a/paper/paper.md b/paper/paper.md index a6fa9ff..6bf8380 100644 --- a/paper/paper.md +++ b/paper/paper.md @@ -1,5 +1,5 @@ --- -title: 'SolidsPy: 2D-Finite Element Analysis with Python' +title: 'SolidsPy: 2D/3D-Finite Element Analysis with Python' tags: - Python - finite elements @@ -35,7 +35,7 @@ JOSS welcomes submissions from broadly diverse research areas. For this reason, The Finite Element Method is a numerical method for the solution of problems in engineering and physics [@bathe]. These problems are commonly written as boundary value problems and involve partial differential equations. -``SolidsPy`` is a simple finite element analysis code for 2D elasticity problems and was designed to be used by researchers in computational mechanics and by +``SolidsPy`` is a simple finite element analysis code for 2D/3D elasticity problems and was designed to be used by researchers in computational mechanics and by students in courses on Computational modeling. It has also been used in graduate courses on Introduction to the Finite Element Method. It uses as input simple-to-create text files defining a model in terms of nodal, element, material and load data. Some feature of ``SolidsPy`` are: - It is based on an open-source environment. diff --git a/src/solidspy/__init__.py b/src/solidspy/__init__.py index 6af58bf..e874782 100755 --- a/src/solidspy/__init__.py +++ b/src/solidspy/__init__.py @@ -14,12 +14,12 @@ __version__ = "1.1.0" __citation__ = """@software{solidspy, - title = {SolidsPy: 2D-Finite Element Analysis with Python}, + title = {SolidsPy: 2D/3D-Finite Element Analysis with Python}, author = {Guarín-Zapata, Nicolás and Gómez, Juan}, - year = 2023, + year = 2025, keywords = {Python, Finite elements, Scientific computing, Computational mechanics}, abstract = {SolidsPy is a simple finite element analysis code for - 2D elasticity problems. The code uses as input simple-to-create text + 2D/3D elasticity problems. The code uses as input simple-to-create text files defining a model in terms of nodal, element, material and load data.}, url = {https://github.com/AppliedMechanics-EAFIT/SolidsPy} diff --git a/src/solidspy/assemutil.py b/src/solidspy/assemutil.py index 6654930..0fc6298 100755 --- a/src/solidspy/assemutil.py +++ b/src/solidspy/assemutil.py @@ -51,7 +51,7 @@ def eqcounter( return neq, bc_array -def DME( +def node2dof( cons: NDArray[np.int_], elements: NDArray[np.int_], ndof_node: int = 2, diff --git a/src/solidspy/femutil.py b/src/solidspy/femutil.py index 23477a7..8fa88a1 100755 --- a/src/solidspy/femutil.py +++ b/src/solidspy/femutil.py @@ -7,16 +7,18 @@ Element Analysis. The elements included are: + 1. 4 node bilinear quadrilateral. 2. 6 node quadratic triangle. 3. 3 node linear triangle. -The notation used is similar to the one used by Bathe [1]_. + +The notation used is similar to the one used by Bathe [BATHE]_. References ---------- -.. [1] Bathe, Klaus-Jürgen. Finite element procedures. Prentice Hall, - Pearson Education, 2006. +.. [BATHE] Bathe, Klaus-Jürgen. Finite element procedures. + Prentice Hall, Pearson Education, 2006. """ import numpy as np @@ -44,6 +46,7 @@ def eletype(eletype: int) -> Tuple[int, int, int]: 8. 2 node beam with axial force (3 DOF per node). 8. 8 node hexahedral elements (3 DOF per node). + Returns ------- ndof : int diff --git a/src/solidspy/postprocesor.py b/src/solidspy/postprocesor.py index c518a7c..fff9c47 100755 --- a/src/solidspy/postprocesor.py +++ b/src/solidspy/postprocesor.py @@ -731,7 +731,7 @@ def stress_truss( >>> import solidspy.solutil as sol >>> def fem_sol(nodes, elements, mats, loads): - ... assem_op, bc_array , neq = ass.DME(nodes[:, 3:], elements) + ... assem_op, bc_array , neq = ass.node2dof(nodes[:, 3:], elements) ... stiff, _ = ass.assembler(elements, mats, nodes, neq, assem_op) ... rhs = ass.loadasem(loads, bc_array, neq) ... disp = sol.static_sol(stiff, rhs) diff --git a/src/solidspy/solids_GUI.py b/src/solidspy/solids_GUI.py index 95ed682..d199d11 100755 --- a/src/solidspy/solids_GUI.py +++ b/src/solidspy/solids_GUI.py @@ -66,7 +66,7 @@ def solids_GUI( nodes, mats, elements, loads = pre.readin(folder=folder) if echo: pre.echomod(nodes, mats, elements, loads, folder=folder) - assem_op, bc_array, neq = ass.DME(nodes[:, -2:], elements) + assem_op, bc_array, neq = ass.node2dof(nodes[:, -2:], elements) print("Number of nodes: {}".format(nodes.shape[0])) print("Number of elements: {}".format(elements.shape[0])) print("Number of equations: {}".format(neq)) @@ -149,7 +149,7 @@ def solids_auto( loads = data["loads"] # Pre-processing - assem_op, bc_array, neq = ass.DME(cons, elements) + assem_op, bc_array, neq = ass.node2dof(cons, elements) if verbose: print("Number of nodes: {}".format(nodes.shape[0])) print("Number of elements: {}".format(elements.shape[0])) diff --git a/tests/test_assemutil.py b/tests/test_assemutil.py index fc005a8..ddd8fd1 100755 --- a/tests/test_assemutil.py +++ b/tests/test_assemutil.py @@ -133,7 +133,7 @@ def uel_ones(elcoord, params): [3, 4, 7, 6], [4, 5, 8, 7]]) mats = np.array([[1, 0.3]]) - assemp_op, bc_array, neq = ass.DME(cons, elements) + assemp_op, bc_array, neq = ass.node2dof(cons, elements) stiff, _ = ass.assembler(elements, mats, nodes, neq, assem_op, sparse=False, uel=uel_ones) stiff_exact = np.array([ diff --git a/tests/test_integration.py b/tests/test_integration.py index b0d9937..aa9b3e0 100644 --- a/tests/test_integration.py +++ b/tests/test_integration.py @@ -42,7 +42,7 @@ def test_4_elements(): [6, 0, 2], [2, 0, 1]]) mater = np.array([[1.0, 0.3]]) - assem_op, bc_array, neq = ass.DME(cons, eles) + assem_op, bc_array, neq = ass.node2dof(cons, eles) stiff, _ = ass.assembler(eles, mater, nodes, neq, assem_op) load_vec = ass.loadasem(loads, bc_array, neq) disp = sol.static_sol(stiff, load_vec) @@ -83,7 +83,7 @@ def test_2_elements(): [2, 0, -0.5], [5, 0, -0.5]]) mater = np.array([[1.0, 0.3]]) - assem_op, bc_array, neq = ass.DME(cons, eles) + assem_op, bc_array, neq = ass.node2dof(cons, eles) stiff, _ = ass.assembler(eles, mater, nodes, neq, assem_op) load_vec = ass.loadasem(loads, bc_array, neq) disp = sol.static_sol(stiff, load_vec) @@ -117,7 +117,7 @@ def test_beams(): [1, 8, 0, 1, 2]]) loads = np.array([ [1, -12000, -24000, -6000]]) - assem_op, bc_array, neq = ass.DME(cons, elements, ndof_node=3) + assem_op, bc_array, neq = ass.node2dof(cons, elements, ndof_node=3) stiff, _ = ass.assembler(elements, mats, nodes, neq, assem_op, sparse=False) load_vec = ass.loadasem(loads, bc_array, neq, ndof_node=3) @@ -145,7 +145,7 @@ def test_eigs_truss(): elements[:, 3] = range(nnodes - 1) elements[:, 4] = range(1, nnodes) - assem_op, bc_array, neq = ass.DME(cons, elements) + assem_op, bc_array, neq = ass.node2dof(cons, elements) stiff, mass = ass.assembler(elements, mats, nodes, neq, assem_op) vals, _ = eigsh(stiff, M=mass, which="SM") @@ -171,7 +171,7 @@ def test_eigs_beam(): elements[:, 3] = range(nnodes - 1) elements[:, 4] = range(1, nnodes) - assem_op, bc_array, neq = ass.DME(cons, elements, ndof_node=3) + assem_op, bc_array, neq = ass.node2dof(cons, elements, ndof_node=3) stiff, mass = ass.assembler(elements, mats, nodes, neq, assem_op) vals, _ = eigsh(stiff, M=mass, which="SM")