From c53f839a374142998c602b7ed0b014147e8c7005 Mon Sep 17 00:00:00 2001 From: woutdenolf Date: Sat, 24 Sep 2022 13:49:10 +0200 Subject: [PATCH] add NXdata transformation field --- .github/workflows/ci.yaml | 5 +- base_classes/NXdata.nxdl.xml | 31 + manual/source/conf.py | 5 +- manual/source/index.rst | 1 + manual/source/notebooks/index.rst | 9 + .../source/notebooks/reference_frames.ipynb | 1267 +++++++++++++++++ requirements.txt | 2 + 7 files changed, 1316 insertions(+), 4 deletions(-) create mode 100644 manual/source/notebooks/index.rst create mode 100644 manual/source/notebooks/reference_frames.ipynb diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 34dc020d45..acce577ea4 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -58,14 +58,15 @@ jobs: run: | make test - - name: Install LaTeX + - name: Install System Packages run: | - sudo apt-get update -y && \ + sudo apt-get update -y sudo apt-get install -y \ latexmk \ texlive-latex-recommended \ texlive-latex-extra \ texlive-fonts-recommended + sudo apt-get install -y pandoc - name: Generate build files run: | diff --git a/base_classes/NXdata.nxdl.xml b/base_classes/NXdata.nxdl.xml index bc450988c4..b5b2005a84 100644 --- a/base_classes/NXdata.nxdl.xml +++ b/base_classes/NXdata.nxdl.xml @@ -158,6 +158,11 @@ to avoid string parsing in reading applications. + + + The name of the field that contains the passive transformation matrix. + + :ref:`NXdata` describes the plottable data and related dimension scales. @@ -390,6 +395,32 @@ An optional offset to apply to the values in data. + + + The passive transformation matrix in homogeneous coordinated. + It describes the transformation from the *data frame* (the axis + values are coordinates in this frame) and the *plotting frame*. + + + + + + + + The type of transformation may be helpful for plotting utilities. + + + + + + + + + + + + + Title for the plot. diff --git a/manual/source/conf.py b/manual/source/conf.py index 51b35e4bb3..279d328d9c 100644 --- a/manual/source/conf.py +++ b/manual/source/conf.py @@ -47,7 +47,8 @@ 'sphinx.ext.viewcode', 'sphinx.ext.githubpages', 'sphinx.ext.todo', - 'sphinx_tabs.tabs' + 'sphinx_tabs.tabs', + 'nbsphinx' ] # Show `.. todo` directives in the output @@ -59,7 +60,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = [] +exclude_patterns = ['**.ipynb_checkpoints'] # -- Options for HTML output ------------------------------------------------- diff --git a/manual/source/index.rst b/manual/source/index.rst index bb47170555..ae6ca1860a 100644 --- a/manual/source/index.rst +++ b/manual/source/index.rst @@ -13,6 +13,7 @@ https://www.nexusformat.org/ user_manual examples/index + notebooks/index ref_doc napi community diff --git a/manual/source/notebooks/index.rst b/manual/source/notebooks/index.rst new file mode 100644 index 0000000000..6be5b0d73b --- /dev/null +++ b/manual/source/notebooks/index.rst @@ -0,0 +1,9 @@ +.. _Notebooks: + +============================================== +Jupyter notebooks for theory and code examples +============================================== +.. toctree:: + :maxdepth: 1 + + reference_frames \ No newline at end of file diff --git a/manual/source/notebooks/reference_frames.ipynb b/manual/source/notebooks/reference_frames.ipynb new file mode 100644 index 0000000000..e446593565 --- /dev/null +++ b/manual/source/notebooks/reference_frames.ipynb @@ -0,0 +1,1267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "48bfab0d-d4c3-411c-869c-c2eeaae7fda0", + "metadata": {}, + "source": [ + "# NeXus reference frames\n", + "\n", + "Reference frames or coordinate systems are used in several NeXus base classes. Here we extend the NeXus class documentation regarding reference frames with mathematical background and examples.\n", + "\n", + "1. [NXtransformations reference frame](#NXtransformations-reference-frame)\n", + "2. [NXsample reference frame](#NXsample-reference-frame)\n", + "3. [NXdata reference frame](#NXdata-reference-frame)\n", + "4. [Euclidean space](#Euclidean-space)\n", + " 1. [Reference frame](#Reference-frame)\n", + " 2. [Change of reference frame](#Change-of-reference-frame)\n", + " 3. [Homogeneous coordinates](#Homogeneous-coordinates)\n", + " 4. [Geometric Transformations](#Geometric-Transformations)\n", + " 5. [Metric tensor](#Metric-tensor)\n", + " 6. [Dual basis](#Dual-basis)\n", + " 7. [Crystallography](#Crystallography)\n", + " 1. [Lattice](#Lattice)\n", + " 2. [Diffraction](#Diffraction)\n", + " 1. [Busing and Levy convention](#Busing-and-Levy-convention)\n", + " 1. [Reciprocal basis](#Reciprocal-basis)\n", + " 2. [Orientation](#Orientation)\n", + "5. [Example utilities](#Example-utilities)\n", + " 1. [Diffraction](#Diffraction)\n", + " 2. [Plotting](#Plotting)\n", + " 3. [Saving](#Saving)\n", + "6. [Examples](#Examples)\n", + " 1. [NXdata crystallography example](#NXdata-crystallography-example)" + ] + }, + { + "cell_type": "markdown", + "id": "27a9c682-6e64-41b0-bc42-2da7bc3cefec", + "metadata": {}, + "source": [ + "# NXtransformations reference frame\n", + "\n", + "The default reference frame in Nexus is the [Nexus reference frame](https://manual.nexusformat.org/design.html#the-nexus-coordinate-system) which is the [standard Euclidean basis](#Reference-frame) with additional conventions for position and orientation of source, sample, detector and other objects.\n", + "\n", + "Objects can be positioned in this reference frame by chaining [proper rigid transformations](#Geometric-Transformations). The [NXtransformations](https://manual.nexusformat.org/classes/base_classes/NXtransformations.html) allow for the representation of such chain: translations are representation by vectors, rotations are represented by _rotation vectors_ (direction and angle) and directions allow defining a different reference frame than the Nexus reference frame.\n", + "\n", + "```\n", + "myentry:NXentry\n", + " instrument:NXinstrument\n", + " mydetector:NXdetector\n", + " depends_on = \"diffr/gravity\"\n", + " diffr:NXtransformations\n", + " gravity = float64(0)\n", + " @transformation_type=direction\n", + " @vector=0,0,-1\n", + " @depends_on=beam\n", + " \n", + " beam = float64(0)\n", + " @transformation_type=direction\n", + " @vector=1,0,0\n", + " @depends_on=distance\n", + " \n", + " distance = float64(0)\n", + " @transformation_type=translation\n", + " @vector=1,0,0\n", + " @depends_on=roll\n", + " \n", + " roll = float64(0)\n", + " @transformation_type=rotation\n", + " @vector=0,0,1\n", + " @depends_on=pitch\n", + " \n", + " pitch = float64(0)\n", + " @transformation_type=rotation\n", + " @vector=0,1,0\n", + "```\n", + "\n", + "In this example we define the reference frame having the Z-axis being vertical and pointing upwards and the X-axis pointing along the beam. Within that reference frame the detector is for translated downstream along the beam and than rolled and pitched." + ] + }, + { + "cell_type": "markdown", + "id": "e03c750e-d5ba-47a6-a99c-c4a5aa4b8f9a", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "# NXsample reference frame\n", + "\n", + "[NXtransformations](https://manual.nexusformat.org/classes/base_classes/NXtransformations.html) can be used to define a reference frame and position a sample\n", + "\n", + "```\n", + "myentry:NXentry\n", + " instrument:NXinstrument\n", + " mydetector:NXsample\n", + " depends_on = \"diffr/phi\"\n", + " diffr:NXtransformations\n", + " phi = float64(0)\n", + " @transformation_type=rotation\n", + " @vector=0,1,0\n", + " @depends_on=chi\n", + " chi = float64(0)\n", + " @transformation_type=rotation\n", + " @vector=0,0,1\n", + " @depends_on=rotation_angle\n", + " rotation_angle = float64(0)\n", + " @transformation_type=rotation\n", + " @vector=0,1,0\n", + "```\n", + "\n", + "When the sample is a single crystal, its orientation can defined by a so-called UB-matrix (the _ub_matrix_ field of [NXsample](https://manual.nexusformat.org/classes/base_classes/NXsample.html)).\n" + ] + }, + { + "cell_type": "markdown", + "id": "560c963e-f77d-4dd0-a106-1782dac2b87d", + "metadata": {}, + "source": [ + "# NXdata reference frame\n", + "\n", + "The axis values in [NXdata](https://manual.nexusformat.org/classes/base_classes/NXdata.html) are the coordinates with respect the reference frame in which the data is plotted.\n", + "\n", + "We will refer to the _data frame_ as the reference frame in which the axis coordinates are provided and the _plotting frame_ as the reference frame in which data is to be displayed.\n", + "\n", + "Example in $\\mathbb{R}^3$:\n", + "\n", + "```\n", + "myplot:NXdata\n", + " @axes = ['Ql', 'Qk', 'Qh']\n", + " @passive_transformation = \"reciprocal_space\"\n", + " Qh = float64(1601)\n", + " @long_name = 'H (rlu)'\n", + " Qk = float64(801)\n", + " @long_name = 'K (rlu)'\n", + " Ql = float64(1201)\n", + " @long_name = 'L (rlu)'\n", + " reciprocal_space = float64(4, 4)\n", + " @transformation_type = 'affine'\n", + "```\n", + "\n", + "The $(n+1) \\times (n+1)$ matrix is the [change-of-frame matrix](#Change-of-reference-frame) or _passive transformation matrix_. It defines a [geometric transformation](#Geometric-Transformations) in [homogeneous coordinates](#Homogeneous-coordinates)\n", + "\n", + "$$\n", + "F=\\begin{bmatrix}\n", + "C_{n\\times n}&T_{n\\times 1}\\\\\n", + "P_{1\\times n}&1\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "where $T$ is the position of the origin of the plotting frame in the data frame and the columns of $C$ are the coordinates of the basis vectors of the plotting frame with respect to the basis of the data frame. $P$ can be used to describe projective transformations like the projections of a sample on a flat detector in full field techniques.\n", + "\n", + "The transformation type is an optional attribute (enumeration) that describes the type of transformation. This can be useful for plotting applications to check whether the provided transformation is supported.\n", + "\n", + "* translation\n", + "* proper rigid: translation + rotations\n", + "* rigid: proper rigid + reflections\n", + "* similarity: rigid + isotropic scaling\n", + "* affine: similarity + non-isotropic scaling and shear\n", + "* linear: affine without translation\n", + "* homography: affine + projection\n", + "\n", + "Note that the [NXdata](https://manual.nexusformat.org/classes/base_classes/NXdata.html) fields _offset_ and _scaling_factor_ should be used to get the real axis values from the stored axis values. These two factors could in principle also be absorbed in the passive transformation matrix.\n", + "\n", + "Most plotting libraries support at least up to affine transformations. [This example](#Plotting) demonstrates the plotting of an image with an affine transformation in $\\mathbb{R}^2$ using the popular python plotting library _matplotlib_.\n", + "\n", + "Note that the change-of-basis matrix is related to the length of the basis vectors and the angles between the basis vectors. For example in $\\mathbb{R}^3$\n", + "\n", + "$$\n", + "C^TC=\\begin{bmatrix}\n", + "a^2 & ab\\cos\\gamma & ac\\cos\\beta\\\\\n", + "ab\\cos\\gamma & b^2 & bc\\cos\\alpha\\\\\n", + "ac\\cos\\beta & bc\\cos\\alpha & c^2\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "where $a$, $b$ and $c$ then lengths and $\\alpha$, $\\beta$ and $\\gamma$ the angles." + ] + }, + { + "cell_type": "markdown", + "id": "1b11b18d-96c2-4258-9a43-cee7f5fc896b", + "metadata": {}, + "source": [ + "# Euclidean space\n", + "\n", + "The mathematics of all reference frames used in NeXus takes place in _Euclidian space_.\n", + "\n", + "Euclidian space $\\mathbb{E}^n$ is an affine space over $\\mathbb{R}^n$ with the Euclidian inner product (a.k.a. the dot product)\n", + "$$\n", + "\\langle.,.\\rangle:\\mathbb{R}^n\\times\\mathbb{R}^n\\to\\mathbb{R}:(\\vec{u},\\vec{v}) \\mapsto \\sum_{i=1}^n u_iv_i\n", + "$$\n", + "\n", + "## Reference frame\n", + "The coordinates $(a_1, \\dots, a_n)$ with $a_i\\in\\mathbb{R}$ of a point $a$ are defined with respect the a reference frame $(o, \\vec{b}_1, \\dots, \\vec{b}_n)$ where $o$ is the origin and $\\vec{b}_i$ the basis vectors so that\n", + "\n", + "$$\n", + "\\vec{oa}=a_1\\vec{b}_1+\\dots+a_n\\vec{b}_n\n", + "$$\n", + "\n", + "The standard reference frame of Eucledian space is the right-handed orthonormal frame with the following basis\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\vec{e}_1=\\begin{pmatrix}1\\\\0\\\\\\vdots\\\\0\\end{pmatrix} &&\n", + "\\vec{e}_2=\\begin{pmatrix}0\\\\1\\\\\\vdots\\\\0\\end{pmatrix} &\n", + "&\\ldots &&\n", + "\\vec{e}_n=\\begin{pmatrix}0\\\\0\\\\\\vdots\\\\1\\end{pmatrix}\n", + "\\end{align*}\n", + "$$\n", + "\n", + "## Change of reference frame\n", + "If $(a_1, \\dots, a_n)$ are the coordinates with respect to reference frame $(o, \\vec{b}_1, \\dots, \\vec{b}_n)$ and $(a_1^\\prime, \\dots, a_n^\\prime)$ are the coordinates with respect to reference frame $(o^\\prime, \\vec{b}_1^\\prime, \\dots, \\vec{b}_n^\\prime)$ then those coordinates are related by\n", + "\n", + "$$\n", + "\\begin{bmatrix}A\\\\1\\end{bmatrix}=\n", + "\\begin{bmatrix}\n", + "C_{n\\times n}&T_{n\\times 1}\\\\\n", + "P_{1\\times n}&1\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}A^\\prime\\\\1\\end{bmatrix}\n", + "$$\n", + "\n", + "where\n", + "\n", + "* $A$ are the coordinates $(a_1, \\dots, a_n)$\n", + "* $A^\\prime$ are the coordinates $(a_1^\\prime, \\dots, a_n^\\prime)$\n", + "* $T$ are the coordinates of vector $\\vec{oo^\\prime}$ in reference frame $(o, \\vec{b}_1, \\dots, \\vec{b}_n)$\n", + "* the columns of $C$ are the coordinates of $\\vec{b}_i^\\prime$ with respect to $(\\vec{b}_1, \\dots, \\vec{b}_n)$\n", + "* $P$ are zeros.\n", + "\n", + "We call $T$ the _translation vector_, $C$ the _change-of-basis matrix_ and the composite $F$ the _change-of-frame matrix_ or _passive transformation matrix_. Note that this matrix maps coordinates from the new frame to the old frame. The _coordinate transformation matrix_ or _active transformation matrix_ which maps coordinates from the old frame to the new frame is the inverse of the _change-of-frame matrix_. Note that the inverse may not exist.\n", + "\n", + "## Homogeneous coordinates\n", + "\n", + "The homogeneous coordinates $(h_1, \\ldots, h_n, h_{n+1})$ of point $a$ with $h_{i}\\in\\mathbb{R}$ and $h_{n+1}\\neq 0$ are defined so that\n", + "\n", + "$$\n", + "a_i=\\frac{h_i}{h_{n+1}}\n", + "$$\n", + "\n", + "The coordinates $(a_1, \\dots, a_n, 1)$ are a special case of homogeneous coordinates.\n", + "\n", + "## Geometric Transformations\n", + "\n", + "A geometric transformation can be represented be the folowing _change-of-frame matrix_\n", + "\n", + "$$\n", + "F=\\begin{bmatrix}\n", + "C_{n\\times n}&T_{n\\times 1}\\\\\n", + "P_{1\\times n}&1\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "Different transformation types can be distinguished based on the properties of the _translation vector_ $T$, _change-of-basis matrix_ $C$ and _projection vector_ $P$\n", + "\n", + "* _translation_:\n", + " * $C$ is the identity matrix and $P$ are all zeros\n", + "* _proper rigid (euclidian) transformation_:\n", + " * $P$ are all zeros\n", + " * $C$ is any orthogonal matrix ($C^T=C^{-1}$) with determinant $\\det{C}=+1$\n", + " * preserves angles, distances and handedness\n", + " * translation + rotation\n", + "* _rigid (euclidian) transformation_:\n", + " * $P$ are all zeros\n", + " * $C$ is any orthogonal matrix ($C^T=C^{-1}$)\n", + " * preserves angles and distances\n", + " * proper rigid transformation + reflection\n", + "* _similarity transformation_:\n", + " * $P$ are all zeros\n", + " * $C=rA$ where A any orthogonal matrix ($A^T=A^{-1}$) and $r\\gt 0$\n", + " * preserves angles and ratios between distances\n", + " * rigid transformation + isotropic scaling\n", + "* _affine transformation_:\n", + " * $P$ are all zeros\n", + " * $C$ is any invertible matrix (i.e. linear transformation)\n", + " * preserves parallelism\n", + " * similarity transformation + non-isotropic scaling and shear\n", + "* _projective transformation (homography)_:\n", + " * $C$ is any invertible matrix (i.e. linear transformation)\n", + " * preserves collinearity\n", + " * affine transformation + projection\n", + "\n", + "The chained _NXtransformations_ allows the definition of a _proper rigid transformations_ because it is meant to position objects like sample, optics and detectors.\n", + "\n", + "Possitive rotations around the x-, y- and z-axis of the standard Euclidean basis in $\\mathbb{R}^3$ are defined by\n", + "\n", + "$$\n", + "R_x(\\theta) = \\begin{bmatrix}\n", + "1 & 0 & 0\\\\\n", + "0 & \\cos\\theta & \\sin\\theta\\\\\n", + "0 & -\\sin\\theta & \\cos\\theta\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + "R_y(\\theta) = \\begin{bmatrix}\n", + "\\cos\\theta & 0 & -\\sin\\theta\\\\\n", + "0 & 1 & 0\\\\\n", + "\\sin\\theta & 0 & \\cos\\theta\\\\\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "$$\n", + "R_z(\\theta) = \\begin{bmatrix}\n", + "\\cos\\theta & \\sin\\theta & 0\\\\\n", + "-\\sin\\theta & \\cos\\theta & 0\\\\\n", + "0 & 0 & 1\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "## Metric tensor\n", + "\n", + "If $A$ and $B$ are the coordinates of $\\vec{oa}$ and $\\vec{ob}$ with respect to a basis $C$ given in the standard Euclidean basis (i.e. the columns are the coordinates of the basis in the standard Euclidean basis) then\n", + "\n", + "$$\n", + "\\langle\\vec{oa},\\vec{ob}\\rangle = A^T\\cdot C^T\\cdot C\\cdot B = A^T\\cdot M\\cdot B\n", + "$$\n", + "\n", + "where $M$ is the _metric tensor_ of the basis $C$. Each element of $M$ is the dot product of two basis vectors\n", + "\n", + "$$\n", + "M_{i,j}=\\langle\\vec{b}_i,\\vec{b}_j\\rangle\n", + "$$\n", + "\n", + "The metrix tensor of the standard Euclidean basis is the identity matrix.\n", + "\n", + "## Dual basis\n", + "\n", + "The _dual basis_ $(b^1,\\dots,b^n)$ of basis $(b_1,\\dots,b_n)$ is defined as the basis for which\n", + "\n", + "$$\n", + "\\langle\\vec{b^i},\\vec{b}_i\\rangle=\\delta_{i,j}\n", + "$$\n", + "\n", + "If $C_{b}$ and $C_{b^\\ast}$ define a basis and its dual basis with respect to the standard Euclidean basis (i.e. the columns are the coordinates in the standard Euclidean basis) then\n", + "\n", + "$$\n", + "C_{b^\\ast}=C_{b}^{-T}\n", + "$$\n", + "\n", + "and the metrix tensors of the two bases are eachothers inverse\n", + "\n", + "$$\n", + "M_{b^\\ast}=M_{b}^{-1}\n", + "$$\n", + "\n", + "Note: in crystallography the dual basis of a lattice basis is referred to as the _recipocal basis_ which spans _recipical space_. The metrix tensor $M$ is referred to as the _Gram matrix_ $G$.\n", + "\n", + "## Crystallography\n", + "\n", + "### Lattice\n", + "In crystallography the _lattice parameters_ $(a, b, c, \\alpha, \\beta, \\gamma)$ describe the metric tensor of the lattice basis\n", + "\n", + "$$\n", + "M=\\begin{bmatrix}\n", + "a^2 & ab\\cos\\gamma & ac\\cos\\beta\\\\\n", + "ab\\cos\\gamma & b^2 & bc\\cos\\alpha\\\\\n", + "ac\\cos\\beta & bc\\cos\\alpha & c^2\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "The full description of the lattice basis however is given by $C$ (the coordinates of the lattic basis vectors with respect to the standard Euclidean basis). The extra three parameters describe the orientation of the lattice basis in the standard Euclidean basis.\n", + "\n", + "The recipical lattice parameters $(a^\\ast, b^\\ast, c^\\ast, \\alpha^\\ast, \\beta^\\ast, \\gamma^\\ast)$ describe the metric tensor in recipocal space\n", + "$$\n", + "M^\\ast=\\begin{bmatrix}\n", + "a^\\ast a^\\ast & a^\\ast b^\\ast\\cos\\gamma^\\ast & a^\\ast c^\\ast\\cos\\beta^\\ast\\\\\n", + "a^\\ast b^\\ast\\cos\\gamma^\\ast & b^\\ast b^\\ast & b^\\ast c^\\ast\\cos\\alpha^\\ast\\\\\n", + "a^\\ast c^\\ast\\cos\\beta^\\ast & b^\\ast c^\\ast\\cos\\alpha^\\ast & c^\\ast c^\\ast\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "The full description of the reciprocal lattice basis however is given by $C^\\ast$ (the coordinates of the lattic basis vectors with respect to the standard Euclidean basis). The extra three parameters describe the orientation of the recipcrocal lattice basis in the standard Euclidean basis.\n", + "\n", + "### Diffraction\n", + "\n", + "A vector $\\vec{h}$ with integral coordinates $H^\\ast$ with respect to the reciprocal lattice basis is a _lattice vector_. The coordinates are called _Miller indices_.\n", + "\n", + "The _scattering vector_ $\\vec{q}$ is the different between the the outgoing and incomming _wave vectors_ $\\vec{k}$ and $\\vec{k}_0$\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\vec{q} &= \\vec{k}-\\vec{k}_0\\\\\n", + "\\lVert\\vec{k}\\rVert &= \\frac{2\\pi}{\\lambda}\\\\\n", + "\\lVert\\vec{k}_0\\rVert &= \\frac{2\\pi}{\\lambda}\\\\\n", + "\\end{align*}\n", + "$$\n", + "\n", + "where $\\lambda$ the wavelength of the primary beam.\n", + "\n", + "Constructive interference can occur if symmetry allows it for a lattice vector $\\vec{h}$ and a primary beam $\\vec{k}_0$ in the direction of $\\vec{k}$ when\n", + "$$\n", + "\\vec{q} = 2\\pi \\vec{h}\n", + "$$\n", + "\n", + "That's fancy way of saying we detect a non-zero scattered intensity in the direction of $\\vec{k}$.\n", + "\n", + "### Busing and Levy convention\n", + "\n", + "W. R. Busing and H. A. Levy (Acta Cryst. (1967). 22, 457-464) define conventions which are followed by the Nexus standard.\n", + "\n", + "#### Reciprocal basis\n", + "\n", + "The reciprocal basis with respect to the standard Euclidean basis is chosen to be\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "\\langle\\vec{b^1},\\vec{e}_1\\rangle &= a^\\ast\\\\\n", + "\\langle\\vec{b^1}\\times \\vec{b^2},\\vec{e}_2\\rangle &= 0\n", + "\\end{align*}\n", + "$$\n", + "\n", + "As a consequence the associated change-of-basis matrix $C^\\ast$, denoted as the matrix $B$, is given by\n", + "\n", + "$$\n", + "B=\\begin{bmatrix}\n", + "a^\\ast & b^\\ast\\cos\\gamma^\\ast & c^\\ast\\cos\\beta^\\ast\\\\\n", + "0 & b^\\ast\\sin\\gamma^\\ast & -c^\\ast\\sin\\beta^\\ast\\cos\\alpha\\\\\n", + "0 & 0 & \\frac{1}{c}\n", + "\\end{bmatrix}\n", + "$$\n", + "\n", + "#### Orientation\n", + "\n", + "The crystal is randomly mounted on a diffractometer and with all diffractometer angles set to zero, the coordinates $H$ of a vector $\\vec{h}$ with respect to the standard Euclidean basis can be calculated from the coordinates $H^\\ast$ with respect to the reciprocal lattice basis\n", + "\n", + "$$\n", + "H=UBH^\\ast\n", + "$$\n", + "\n", + "where $U$ the _orientation matrix_. Integral coordinates $H^\\ast$ are referred to as _Miller indices_ and are the coordinates of the _lattice vectors_. The inverse of the norm of a lattice vector is the _d-spacing_ and the lattice vector is normal to the lattice planes associated to the Miller indices.\n", + "\n", + "For a 3-circle diffractometer the sample can be rotated by\n", + "\n", + "$$\n", + "Q=R_z(\\omega) R_y(-\\chi) R_z(\\phi)H\n", + "$$\n", + "\n", + "where $(\\omega, \\chi, \\phi)$ is referred to as the _sample orientation_.\n", + "\n", + "The _NXsample_ class defines these fields \n", + "\n", + "* _unit_cell_: lattice parameters $(a, b, c, \\alpha, \\beta, \\gamma)$\n", + "* _orientation_matrix_: the orthogonal $U$ matrix\n", + "* _sample_orientation_: 3-circle diffractometer angles $(\\omega, \\chi, \\phi)$\n", + "* _ub_matrix_: the matrix product $UB$" + ] + }, + { + "cell_type": "markdown", + "id": "440da950-7b75-4328-aed4-8fe6d2d7c649", + "metadata": {}, + "source": [ + "# Example utilities\n", + "\n", + "Here we define some methods for the examle\n", + "\n", + "## Diffraction\n", + "\n", + "Some useful helper functions for crystallography" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7ca2437a-a3cd-4034-8cd7-a8e5a4709c1a", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "from scipy import constants\n", + "from scipy.constants import physical_constants\n", + "\n", + "\n", + "def cos(angle_deg):\n", + " return numpy.cos(numpy.radians(angle_deg))\n", + "\n", + "\n", + "def sin(angle_deg):\n", + " return numpy.sin(numpy.radians(angle_deg))\n", + "\n", + "\n", + "def arccos(cosangle):\n", + " return numpy.degrees(numpy.arccos(cosangle))\n", + "\n", + "\n", + "def lattice_to_metrix_tensor(lattice):\n", + " aa = lattice[\"a\"] ** 2\n", + " bb = lattice[\"b\"] ** 2\n", + " cc = lattice[\"c\"] ** 2\n", + " bc = lattice[\"b\"] * lattice[\"c\"] * cos(lattice[\"alpha\"])\n", + " ac = lattice[\"a\"] * lattice[\"c\"] * cos(lattice[\"beta\"])\n", + " ab = lattice[\"a\"] * lattice[\"b\"] * cos(lattice[\"gamma\"])\n", + " return numpy.array([[aa, ab, ac], [ab, bb, bc], [ac, bc, cc]])\n", + "\n", + "\n", + "def metric_tensor_to_lattice(M):\n", + " lattice = dict()\n", + " lattice[\"a\"] = M[0, 0] ** 0.5\n", + " lattice[\"b\"] = M[1, 1] ** 0.5\n", + " lattice[\"c\"] = M[2, 2] ** 0.5\n", + " lattice[\"alpha\"] = arccos(M[1, 2] / (lattice[\"b\"] * lattice[\"c\"]))\n", + " lattice[\"beta\"] = arccos(M[0, 2] / (lattice[\"a\"] * lattice[\"c\"]))\n", + " lattice[\"gamma\"] = arccos(M[0, 1] / (lattice[\"a\"] * lattice[\"b\"]))\n", + " return lattice\n", + "\n", + "\n", + "def lattice_to_reciprocal_lattice(lattice):\n", + " M = lattice_to_metrix_tensor(lattice)\n", + " Mr = numpy.linalg.inv(M)\n", + " return metric_tensor_to_lattice(Mr)\n", + "\n", + "\n", + "def busing_levy_reciprocal_basis(lattice):\n", + " rlattice = lattice_to_reciprocal_lattice(lattice)\n", + " br1 = [rlattice[\"a\"], 0, 0]\n", + " br2 = [\n", + " rlattice[\"b\"] * cos(rlattice[\"gamma\"]),\n", + " rlattice[\"b\"] * sin(rlattice[\"gamma\"]),\n", + " 0,\n", + " ]\n", + " br3 = [\n", + " rlattice[\"c\"] * cos(rlattice[\"beta\"]),\n", + " -rlattice[\"c\"] * sin(rlattice[\"beta\"]) * cos(lattice[\"alpha\"]),\n", + " 1 / lattice[\"c\"],\n", + " ]\n", + " return numpy.array([br1, br2, br3]).T\n", + "\n", + "\n", + "def rotx(angle):\n", + " c = cos(angle)\n", + " s = sin(angle)\n", + " return numpy.array([[1, 0, 0], [0, c, -s], [0, s, c]])\n", + "\n", + "\n", + "def roty(angle):\n", + " c = cos(angle)\n", + " s = sin(angle)\n", + " return numpy.array([[c, 0, -s], [0, 1, 0], [s, 0, c]])\n", + "\n", + "\n", + "def rotz(angle):\n", + " c = cos(angle)\n", + " s = sin(angle)\n", + " return numpy.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])\n", + "\n", + "\n", + "def simplified_diffraction(Q, C, N):\n", + " # Q: p x n (rows are the coordinates)\n", + " # C: n x n (columns are the basis vectors)\n", + " # N: n (number of unit cells in each direction)\n", + " # returns: p\n", + " if Q.ndim == 1:\n", + " Q = Q[numpy.newaxis, :] # 1 x n\n", + " x = (Q.dot(C)).T / 2 # n x p\n", + " M = numpy.array(N)[:, numpy.newaxis] # n x 1\n", + " with numpy.errstate(divide=\"ignore\", invalid=\"ignore\"):\n", + " g = numpy.sin(x * M) ** 2 / numpy.sin(x) ** 2\n", + " for gi, Ni in zip(g, N):\n", + " gi[numpy.isnan(gi)] = Ni**2\n", + " g = numpy.product(g, axis=0)\n", + " transmission = numpy.all(numpy.abs(x) < (numpy.pi / 2), axis=0)\n", + " g[transmission] *= 2\n", + " return g\n", + "\n", + "\n", + "kev_angstrom_factor = (\n", + " constants.h * constants.c * 1e7 / physical_constants[\"electron volt\"][0]\n", + ")\n", + "\n", + "\n", + "def wavelength(energy_keV): # m\n", + " return kev_angstrom_factor / energy_keV * 1e10\n", + "\n", + "\n", + "def wavenumber(energy_keV): # m^-1\n", + " return 2 * numpy.pi / wavelength(energy_keV)\n", + "\n", + "\n", + "def test_utilities():\n", + " lattice = {\"a\": 1, \"b\": 1.2, \"c\": 1.3, \"alpha\": 70, \"beta\": 60, \"gamma\": 80}\n", + "\n", + " # Test metric tensor\n", + " M = lattice_to_metrix_tensor(lattice)\n", + " Mr = numpy.linalg.inv(M)\n", + " lattice2 = metric_tensor_to_lattice(M)\n", + " numpy.testing.assert_allclose(list(lattice.values()), list(lattice2.values()))\n", + "\n", + " # Test reciprocal lattice basis\n", + " B = busing_levy_reciprocal_basis(lattice)\n", + " numpy.testing.assert_allclose(Mr, B.T.dot(B))\n", + "\n", + " # Test lattice basis\n", + " C = numpy.linalg.inv(B.T)\n", + " numpy.testing.assert_allclose(M, C.T.dot(C))\n", + "\n", + " # Test norm\n", + " h = numpy.array([1, 2, 3])\n", + " norm1 = sum(B.dot(h) ** 2) ** 0.5\n", + " norm2 = (h.dot(Mr).dot(h)) ** 0.5\n", + " numpy.testing.assert_allclose(norm1, norm2)\n", + "\n", + " # Test diffraction\n", + " N = numpy.array([1, 2, 3])\n", + " h = numpy.array([2, 2, 0])\n", + " Q = 2 * numpy.pi * B.dot(h)\n", + " intensity = simplified_diffraction(Q, C, N)\n", + " numpy.testing.assert_allclose(intensity, numpy.product(N**2))\n", + " h = numpy.array([0, 0, 0])\n", + " Q = 2 * numpy.pi * B.dot(h)\n", + " intensity = simplified_diffraction(Q, C, N)\n", + " numpy.testing.assert_allclose(intensity, 2 * numpy.product(N**2))\n", + "\n", + " # Test d-spacing\n", + " a = physical_constants[\"lattice parameter of silicon\"][0] * 1e10\n", + " lattice = {\"a\": a, \"b\": a, \"c\": a, \"alpha\": 90, \"beta\": 90, \"gamma\": 90}\n", + " M = lattice_to_metrix_tensor(lattice)\n", + " Mr = numpy.linalg.inv(M)\n", + " h = numpy.array([2, 2, 0])\n", + " hnorm = h.dot(Mr.dot(h)) ** 0.5\n", + " d220 = physical_constants[\"lattice spacing of ideal Si (220)\"][0] * 1e10\n", + " numpy.testing.assert_allclose(d220, 1 / hnorm)\n", + "\n", + "\n", + "test_utilities()" + ] + }, + { + "cell_type": "markdown", + "id": "684175cd-902c-4236-8b01-6ac697af113a", + "metadata": {}, + "source": [ + "## Plotting\n", + "\n", + "Plotting with an affine transformation using _matplotlib_" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4473fbe2-5e6d-47ca-a441-53e4830abdab", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAANMAAAEICAYAAADFicGBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkZklEQVR4nO2deZhcVbmv36+ndObOPKfHkKkTQBoEwefEHGQUIUc5AoIyHa5ycDhXr6IXrx7lOh2Pio8ePVEQVAiOqKDABZIQgjIkkKSTdIAknU466YydztBJT9Xf/WPvCtWd6q7a1Xvu9T5PPd1Ve9daX+1dv1pr/fb61hZVxWAwDJy8oAMwGOKCEZPB4BJGTAaDSxgxGQwuYcRkMLiEEZPB4BIDEpOIrBSR290KRkR+IiJfcqu8XmUvEZFdInJcRM72og6vEZEvisjP+tl+s4isdqmuRSLS6EZZdnkz7WOf71aZYSOjmERkh4ictA/EPhH5uYiMcFKJiJSJiIpIQcprp514Vf2Yqn7NSdkO+A5wl6qOUNXXParDU1T166p6O6Q/pkEhIg+KyL29XtshIhcnn6vqTvvYJ/yP0B+ybZmuUtURwDuAc4F7vAvJM0qBTek2hOELaYgBqtrvA9gBXJzy/D+AJ+z/VwK32//nYYmsAdgP/AIYbW/bCShw3H5cALQBCft5i73fg8C99v+LgEbgM3Z5TcAtKXGMAx4HjgKvAvcCq9PEP8SuQ4FWYFvK5/o8sAFoBwqAu4FtwDFgM7AkpZybgReB7wEtwHbgXfbru+wYP9qr3u/Yn30f8BNgaB/HuAE4x/7/RjvWefbz24E/2v9/BfhVP8f0ZmC1Xe9hoB64PMO5/YL9WQ8DPweKU49/yr5z7fPdgvWj9H779TuATqDDjuNx4JdAN3DSfu1zQJkdb0HKd+dr9jE9Bvw/YHxKfR+xj8sh4Ev0+h72+hxXAq/b34VdwFdStn3IPlej7OeXA3uBCfbzW4E6+/M/DZTar4t9rvcDR7C+J9X9asWJmIAZ9oH8Whox3QpsBSqAEcAfgF/a23ocyJQv5+pedT1ITzF1AV8FCoErgBPAGHv7o/ZjGDDPPoiniSmlbAWqen2udfZnGmq/di0wFeuH4UNY4puSEm8XcAuQjyXencCPsIRzif2lGGHv/33gz8BYYCTWl+wbfcT2C+Az9v9LsQT98ZRt/5ZGTH0d007gX+wYPw7sAaSfc7vRPgZjsb7YPX7M7P8L7XP7RaAIWGx/1tm9z1s/P8I94sX67mwDzgCG2s+/aW+bhyXCi+z6vmN/rr7EtAhYYJ+3hVg/XtekbH/YjnGcfTzeZ79+jf255mL9mN4D/M3edimwFijBEtZc7O/CQMV0HOsXqQH4L97+8q3kbTE9B9yZ8r7Z9gEo6OfEZxLTyV7v2Q+cb39ROpMn096WtmXKIKZbM3z2dcDVKfG+lbJtgV3mpJTXDgFn2Qe/FahM2XYBUN9HPbcBf7b/r8NqjR61nzcA73Agpq0pz4fZ+0zu59x+LOX5Fbzdci/ibTG9G+vXPC9l32XYLQC5i+melO13Ak/Z//8fYFmvz9FBH2JK87m+D3wv5XkJ1g9fLfDfKa8/CdyW8jwP6we7FOsH4037+5aXTb3ZjpmuUdUSVS1V1TtV9WSafaZinfgkDVhCmpRlHek4pKpdKc9PYLV6E+yyd6VsS/0/W3q8R0Q+IiLrRKRFRFqAamB8yi77Uv4/CaCqvV9LxjcMWJtS1lP26+l4Hni3iEzG+qH4NXChiJQBo7FEnS17k/+o6gn73/4Mo9Rj0IB1HnszFdilqt299p3mIK507E35P3luT9WX3GB/jkN9FSIi7xSRFSJyQESOAB8j5bypagvwW6zz+Z8pby0F7ks5R81YP4TTVHU58EOsnsc+EVkqIqP6+zBuXmfaYweXZCZWt2gf1i9Sb9K9li0H7LKnp7w2I4dyTsUgIqXAT4G7gHGqWoLVBZIcyj2IJaz59o9QiaqOVsvEOT0I1a1YX6ZPAqtU9RjWF+0OrNa2O93bcogrHanHbSbWeezNHmCGiOT12nd3P7EMJL4mUs6tiAzF6qL1xSNYXeoZqjoaa3x66ryJyFlYw5BlwA9S3rcL+B8p56hEVYeq6t8AVPUHqnoOMB+rO/q/+gvaTTEtA/5NRMpt6/zrwK/tluUA1oC0ImX/fcB0ESlyWpFa9uofgK+IyDARmYM1YB0Iw7G+AAcAROQWrF8yx9hf/p8C3xORiXZ500Tk0n7e9jyWkJ+3n6/s9bw36Y5pLvyriEwXkbFYY6Jfp9nnZaxu6+dEpFBEFgFXYY1ZwTqXveNI91q2/A64SkTeZX8//p3+f9RGAs2q2iYi5wE3JDeISDHwK6zPdgswTUTutDf/BPiCiMy39x0tItfa/59rt3iFWJ89aZj1iZtiegDLxVmF5SK1AZ+AU830/wVetJvU84HlWGbGXhE5mEN9d2F1gfba9S7DcuVyQlU3Y3UB/o71RViANSDPlc9jDW5fEpGjwLNY48i+eB7rS7Gqj+e94013THPhESwnbbv9uLf3DqraAbwfywk7iDVu/oiqbrF3uR+YZ8fxR/u1bwD32K991klAqroJ67vzKFYrdQxrvNzX+b0T+KqIHMMab/0mZds3sMZ+P1bVdiy39F4RmaWqjwHfAh61z9FG+zMCjML6QTzM267id/qLW+yBV+QRkW9hDbQ/GnQsUUFEdmAZSM8GHUt/2D2dFmCWqtYHHE6fRHZunojMEZGFYnEeliP2WNBxGdxBRK6yu/DDsVqEWiyHMLRE+cr/SKyu3VSsLsB/An8KNCKDm1yN1X0XYA1wnXrcjbJb6mNYY6MuVa1x9P64dPMMhoFii6lGVXMZw0e3m2cwhI1Ytkzjx4/XsrKyQGNoP9FB44njjM0fwsgRxRQUxjbzIGfWrl17UFX7upCdFZe+Z7geas48EX3thvZNWA5zkqWqujR1HxGpx3LvFGumRI/tmYjymKlPysrKWLNmTaAxPPPEOj52/C8AHBdhUets/nl8BRf+wxkMHz080NjCgog0ZN6rfw42J3j56ekZ9yucsq0tizHQhaq6x742+IyIbFHVtJcm0hFLMYWBLS1HTh1dVWXFsC2sOLGF/L88w1Xt8/inaWWc+w+zKRpSGGygkUdJpJ0gkkNJqnvsv/tF5DHgPPq4zpcOIyaPqO04lPboJvI6+ePQ9fyxeT3Dfjuca7vmcXVVKdUXVJGfb7qCTlGg24WZVbYFn6eqx+z/L8HKWMgaIyaPWF+wP+M+JwpaeajgVR5qfJXxD4/jBpnDFdWlVJ1VhkguUwIHJ9240jJNAh6zj3sB8IiqPuWkACMmDzjafIyDRX1Ock7LwaJD/IAX+cEbL1K+bgo3Fc/h4nPLmVY1xaMo44GidLrQzVPV7cCZAynDiMkDdtQ1Dej99UOb+CpNfHXNCs5eVc4No2ex6MIqxk4e41KE8UGBhGsT6AeGEZMHbN97xLWyXh9Wz+ud9cjzz/Ce1jlcO8F2BEcNc62OqOPGmMkNjJg8YNPxFiuR3UVUleXD6ljeWkfBE8/w/ra5XFNZxbnnVw5qR1CBREiulRoxeUBtwtl4ySldeR38Ydh6Csc8wAPrZzJl75VcO7GC6nPLBqUj6I4xPnCMmFxGVakdMrAxkxMmFe+ku+zH/Br45ssLeMehf2RJaRmVC2YMCkdQUTNmiiv7Gg7Qln8i844D5EPz1p72WvmIWg6PqOUBYMuqd3P58Qu4ck4ZUysnex5PUKhCZzi0FH4x2WnHq7BGIQXA71T1y8FG1Tc7th0IOgQA5ox5gfoxL/DDVnjjmau4LnEmF59dwZhJJUGH5jJCIqdlOtwn9GLCSlVerKrH7Xz81SLypKq+FHRg6Xjr4NGgQziN2ZMe53Ue59W9Bexdey03FM3l3edVxMIRVKDbtEzZYSeEHbefFtqPkBy+06k90WwtqRhCCqSL6dOXsQp4cutound/gOtHz6LmnRWRdgRNy+QA+84Ja4Eq4Eeq+nKafe7AWhqLmTNn+htgChvIKa/Md4YXHIHSB3gCuH/9TKbuu5IPTqxgwbnl5OVFJ83NumhrxJQ19tJeZ4lICdb8qWpV3dhrn6VYSwtTU1MTSMvV0d7JtqHplp1zl3Tmw0CYVLyTRKntCL60kHMOLWZJWTkV1dND7wgq0KnhEH8kxJREVVtEZCVwGdayTKFi15Y9bk26DIzyERtoHrGB+xXKt42jq/F2riktZ0r5xKBDS4siJEKSMB56MYnIBKDTFtJQ4GKstc5Cx47Gw0GH4Cq3jVgJc1YC8NVNNzPr4JVcNqcsdI5gt4aj9Qy9mIApwEP2uCkP+I2qPhFwTGnZcvhINI5oDtwz7kEY9yDt3d189vW7Wdx6IYvOLGfYyGDdFjNmcoCqbgAicdvM2o7mCBzR7Lh3Ym3a14dIHt+e8m0A9h9N8MVN/8G1LOTcs8sCcgSFhBkzxY/1+ZkTAuPExPx8vlt2NwC1+4t5tOE7XD9sNtVnzfTNEbQybY2YYsWxw8fZP8R7W9xtJ88tFhS2saDqLgCe3lnJ+oYvcu2ESirmTvXUEVQVOjQck3uNmFyiYYt/k1vDzqXF27h09m0A/HTbYrobb+VqDx3BbjNmihfbXEwIjBO3j1gOc5YD8O+bbmH2wSu4dG45YyaOdqV8y4Aw3bxYUXe0xfWEwKDoy3wYKF8a93MY93PaE918es1XXCrVGBCxY33XodiIyWuGSB4Vo15zpawwGRDhiCLiWAmB3k8jihM7Di1yrayESsaHH5iWyQX27zzIyYJgEgKjyryOdPehdo4idGo4vsbhiCLi7NgajoTAKFFdPNaVcowBETPCmBAYdiqmuuXm+deNy4QRkwtsPHEotAmBTvHKyUvljc4C5kwf51p5xoCIEetzu9HcoGXZkVtdmxWhCgnNy/jwA9MyDZDOjk62DjWzH5yQaDnLtbIsA8JMJ4oFjW/soVsy37luoMTJyTsz4e60ImNAxIT6nS1BhxA55o8qca0sRUxyYFx4o+UIhKOXERnKKsa7Wl5YWqZwRBFhatubgw7BNfxw8p5om+3qPX2tdfPyMj78wIhpgKzP3xd0CJFiZfMHXS7RWtE108MPTDdvALQeaWXvIE4IzIUpxypdLc9a6isc/WwjpgFQX2cmtzplYb674yVV8a0blwkjpgGwvclMI3LKGePcmUaUipsXZe1VsNYAu1X1fU7ea8Q0ADYfa4GioKNwBz/MhxPd3UyvnOBqmVY+k6tjok8BdcAop28MR/sYUWo7zTQiJzx0/EoKi9xeDkxcm04kItOBK4Gf5RKJaZlyRFXZ4OMdAuPA1uZFrpdpWeNZtUzjRWRNyvOl9vr0qXwf+BwwMpdYjJhy5EDjIU4UtHpeT5ycvLnt010v08HcvIOqWtPXRhF5H7BfVdeKyKJcYjFiypEdbw2uBSfdoHqIOwmBvXEpBeNC4P0icgVQDIwSkV+p6o3ZFmDGTDmy1SQEOqZyivtOnpWCMfA1IFT1C6o6XVXLgOuA5U6EBKZlypmNreG9Q6BT/HDytnblMWumu9eYkoRloqtpmXIkKncIDAsPt7iXEJiKNWvc3bl5qrrS6TUmMC1TTnR1dvFmsZn94ISuw97cyMTcOTDiNL7ZRMIkBDpiYbdXdx4004kizY6d8bpDoB/MGznGs7LNwv0RZkuzSQh0Slm5e6sRpZJ088JAONrHiFHbfijoEFzDDyfv6bZKRo4Z4Vn5JjkwwqwbZHcIHCjPNv+zZ2Un14DI9PAD081zSOvRE+wd4v1yyHEyHyYeq/KsbAW6jAERTRpMQqBj3E4I7I1x8yLK9iZzh0CnzB7r/jSiU/jYjcuEEZND6o62mIRAB7RrN9MrvbrG5ElyYM6Eo32MEOs74+Pk+cFDxy+laIjbCYE9CYsBYcTkAFVlQ9HeoMOIFFsOXexp+cnkQCOmLBCRGSKyQkTqRGSTiHwqqFgO7WmmtfCY5/XEycmb2+Z+QmAqitDVnZfx4QdRGDN1AZ9R1ddEZCSwVkSeUdXNfgdiEgKds8ClOwT2R1jGTKEXk6o2AU32/8dEpA6YBvgupq37TUKgUyome+jkAajJZ8oJESkDzgZeTrPtDhFZIyJrDhzw5qLqxlazrrgT6rtgUqm315jMmCkHRGQE8Hvg06p6WhOhqktVtUZVayZMcHdttiTrTUKgI3515BZPEgJ7ExYxhb6bByAihVhCelhV/xBEDCYh0Dlth8/xvA5FSPhkMGQi9GIS66ftfqBOVb8bVBy732qiS7o8rydOTt7CxCRf6gmLAREOSffPhcBNwGIRWWc/rvA7iB0NJiHQKfNHlnheh6rp5mWNqq6G4H963jh8NBo/PSGirMybhMDeqHHzokVtW3ymEfnh5D3XPpNRY3NaZdgh4clnMmLKkvV53ucwxYmnm6/zrS5Vyfjwg9B388LAiWMn2V3s/e0242Q+jDt6hi/1qEKiOxzdPCOmLGio2x10CJHjzHxvrvWlIyxunhFTFtTvMdOInOJpQmAKSngMCCOmLNhsEgId0a7dzPAwIbAn4cm0NQZEFmzoio+T5we/bL3Y84TAVFQzP/zAiCkDqsqGApMQ6ITNh97ra33GzYsIh5oOc6zI+zFTnJy82Sdn+FaX5eaFo00wYspAw5veW+Jxw6s7BPaFX924TBgxZWDrAePkOaXK64TAXhg3LyJsbD1s3eE0Bvjh5O1KdDPD44TAVBT/xkSZCEdnM8Rs6DYJgU74RcvN5OX5+7XSLB5+YFqmfkh0JagzCYGOON5S42+FCurCdCIRKQZWAUOwdPE7Vf2ykzKMmPph99a9JPI6Pa8nTk7ewq7JvtfpUjevHVisqsftzO7VIvKkqr6UbQFGTP2wY0d8FlDxi/kjSnyv0w03T1UVOG4/LbQfjko2Y6Z+eLPZLNLvlPJSfxICkyTn5mVx0XZ8cvUq+3FH77JEJF9E1gH7gWdU9bRVsPrDtEz9UNvWDMOCjsId/HDyVrRP5x8nj/K8nh4okF0376Cq9jugU9UEcJaIlACPiUi1qm7MNhTTMvWDSQh0xpPN1wdSr9tz81S1BVgJXObkfUZMfXCytY1dxd7PyYuT+TD2mD8JgT0RtDvzI2MpIhPsFgkRGQpcDGxxEonp5vWBSQh0zkLxLyGwB+5cSJoCPCQi+ViNzG9U9QknBRgx9UH9bmM+OGXOGH+nEQHWdSYXrHFV3YC19HbOGDH1weYjLSYh0AGdqsyojHTLNGDMmKkPajvNNSYnPNz6DwwZOiSg2iWLh/eYlikNqsr6oqagw4gUG5ovDa7y7uCqTsWIKQ2H97VwtNAkBDqh6sTMYCrO/jqT5xgxpaG+dicVN6wDYPsjZwUaS1RY6HNCYComOTDE1NfuPPV/UlRghNUflRMDcPKSGDGFl/qNO9O+HkVh+eHk7U4kmFYekJMHppsXZlJbpr6IorC84pdHP8IXpwVnDItpmcJJIpFg5+ZGR+8Z7OOrluZ3Ble5Cpi1xsNJ07Z9tJ/syOm9qa0V9C+uODl5C7v8uUNgn5iWKZxk08XLlsHSYs0fPibYAIyYwombYkoS9/FVeWlwtjgQGjGZ6US92F7b4Gn5FTeso+KGdfz9f57naT3gj5P3t46JlEwI2BZXyfzwAdMy9cKLlqkvUgV1wXdf8a1eN3m8+UYuCmjyQxLj5oWQthPtNG0LZjnkpLCiJqqRR+cGHUJounlGTCk0bNqF+jA3pWvxOX1u6939C7u4Fop/q7f2hWmZQoifXbxsCXuLNackwPFSEjMDInyEUUxJnI6v/DAfEqrM9O0OgX3g5/rHGTBiSqGvOXlhIyzGxaMn3sVNU4JKCEzBiCl7ROQB4H3AflWt9qqeMLdMfRGksNY2X8FNlb5WmRYxyYGOeBD4IfALryo4vP8ILfu9X0SlP/NhoPQwL37lfTevqrXU8zqywrRM2aOqq0SkzMs6otgq9Uf1fXee+n/jp/7LkzoWFPm7FHI6RMPj5sVmBoSI3JFcR/rAAecrse6ImZhSqb7vzh7icouqSSFw8sDMgHAbVV0KLAWoqalx/FtV7/E0Ij/Zd256U6C3oAbSYu1NdDG5LPhrTEBounmxaZkGSlScPDcZSIv1i6M3kp+f73JEuZHs6vX38IPYtEwDIZFIsGPjrqDDCIxcxleHms/3KhxnqHHzHCEiy4BFWPfYaQS+rKr3u1V+0/b9OScEOsFLJ88tshXWgq4pfoSTHSHp5kVCTKrq6b1K4ubkuUV/wpo/rMTnaPrBiCk8xNnJc4uksJKiqpgZcEJgCmGxxo2YgPqN8Xfy3KL6vjuZKENZ+fUST+uJIkZMmG6eUxYUh6dVAkw3Lyy0n2xnz1bv7xAYJ+aOKgk6hLcxbl54aNjcSHd3sAmBUaPS75tAZ8K0TOHAdPGcU1YZkpkP2HdfMmIKB0ZMzsgDZs6bHnQYPQmJmAb9dKI4TSPy2skDqMwfzdDhxZ7XkzVZTCXKpuUSkRkiskJE6kRkk4h8ymkog75lMteYnFE9LODVW9PhjgHRBXxGVV8TkZHAWhF5RlU3Z1vAoG6ZWg4coXlvi+f1xMl8mB3EHdUz4EbLpKpNqvqa/f8xoA6Y5iSOQd0ymfGSc8qnhU9MWY6ZxovImpTnS+20ndOwE1HPBl52EoYRk8ERZbMnBx1CT7JfneigqtZk2klERgC/Bz6tqo5ubGzEFBP8MB+Gks/UqpCJCfescREpxBLSw6r6B6fvH9Ri2hEjJ88P5hWODU1CYA9cEJOICHA/UKeq382ljEFrQHR3d7Nj0+BNCMyF+SNKgg4hLdKd+ZEFFwI3AYtFZJ39uMJJHIO2Zdpbv5+21nbP64mTkzdrfMimEYFrK7qq6mqsCRU5M2jFFKfxkl+UzigJOoTTEAaoABcxYjJkTXn1jKBDSE9IphMNXjHFyHzww8kbL8WMnVzieT25YCa6BoxpmZyxsHgsluEVQoyYgqOjrYPdbzUFHUakCFVCYComOTBYdtbtpjvh/RmIk5NXOSmETl4S0zIFh+niOae0IjwJgb0xY6YA2b4hPqsR+UXZ/JAlBKZixBQcxslzRlXeKIaOGOp5PbliWqYAMd08Z8wfFrKlvVJR3EoOHDCDTkxHDx2juemw5/XEyXwIY0JgErOgSoCYVsk5FVND7OSBGTMFhRGTc0rDlhDYC9FwqGkQiik+Tp4f5kMx+UyfFaLbx/TGpVnjbjD4xBQjJ88P5haOIb8ghAmBKZgxUwB0d3cP6jsE5kL1iBAu7dULM50oAPY1HODk8TbP64mTkxfKhMDemJbJf4z54JyyECYE9sDHG0BnwojJ0C+hnkaUxIjJf+K0GpEfTt44ihk3JdxjJnPRNiDMBFdnLAhzQmAK4sP9tbJh0Iipo72TxjdNQqATQpsQmIq5zuQ/O+saTUKgQyonjQw6hKww1rjPGPPBOWXl44IOITtMy+Qv5j5Mzimrnhl0CFkRFgMiEssji8hlIvKGiGwVkbtzKSNO04j8cPLK80YybGR4EwJPoYBq5ocPhF5MIpIP/Ai4HJgHXC8i85yWY7p5zlgwNMQJgb1waa3xARN6MQHnAVtVdbuqdgCPAlc7KeDY4eMc3N3sSXCpxMl8mD02vAmBqSSvMw30zoFuEAUxTQNSZ6c24vD2iKZVck7FlAjMyYPsunimm3eKdFcNTzs6InKHiKwRkTUHDhzosc2IyTmhu0NgP5iWKXsagdQV46cDe3rvpKpLVbVGVWsmTJjQY1ucxOSH+VBEPtPCnBDYG83i4QNRENOrwCwRKReRIuA64M9OCoiTk+cH8wrGUFAYnasmYWmZQn/EVLVLRO4CngbygQdUdZOD95trTA4J6x0C06JAIhwXmkIvJgBV/Svw11zeu6/hACeOnXQ5otOJk5N3xvhoOHlJzEVbn4jTeMkvyqZHS0xuuXki8oCI7BeRjbmEYcRkOI1IJASm4OKY6UHgslzjiL+YYmQ++OHkjWEI46dFZ/ZDVk5elmJS1VVAzlf3IzFmGgjGfHBGVBICkwgg2RkQ40VkTcrzpaq61M1YYi2mzo5Odr1x2iUpQz/MHVkSdAiOyXJF14OqWuNlHLEW064te0h0JTyvJ05OXlWY7xCYDpNp6w/GfHBOaVmExksA+Df3LhOxNiDitK64X5RXz8i8U8hwy80TkWXA34HZItIoIrc5iSPeLZNx8hxRljeS4aOHe16P67jUMqnq9QN5f7zFZLp5jqgO8x0C+0KzdvM8J7ZiOt7SyoFdhzyvJ07mw5ySiJkPScKhpfiKKU6rt/pF+ZSITSOyMTc785jtG4yYnFJ2xqSgQ8gNIyZviZOT54f5UEgeM2ZP9bwe11HM3da9Jk5Onh/MjVhCYBJBTTfPa8wdAp0RhTsE9kl3OJqmWIqpq6OL1iMnvK8nRk7erHERdvLCoaV4iqn9ZEfQIUSOyCUEpmC6eR5ixOSc8nmOliIMF0ZM3tERIzH54eSVMIQJM8Z7Xo83hGeiayzFZFomZywYEq2EwB6Y1Ym8pbCogLzOPF9ubhYH5kXhDoH9EJYxUyxTMKZWTebR3Uv51/tuZe75szypI05OXuXEiDp5SUKy1ngsWyaAMRNHc80nLueaT1zOnm17WbHsRZ575AV2bdkddGiho6wswteYFAjJDaJj2TL1ZmrlZD58zwe4f9P3+PHab3PtZ66K1go8HhOVOwSmJzx3wYhty5QOEaHq7HKqzi7n9m/dSO2qOp57+AVe+P1LHG9pDTq80/DDyZuZN4IRJRFMCEwlJGOmQSWmVPLy8jhz0XzOXDSfu354G2ueWsdzj7zAS4+voaOtM+jwfCNKdwhMiwIhMZoGrZhSKRpSyLuuPpd3XX0urUdP8OJjr7B82Wpef3YD3Wn643EyH+aURHfmg4WCGjGFkuGjhnHJRxdxyUcXcXhfCyt//TeWL1vNlpffCjo0TyifHHEnD0w3LwqMmVTCkk9ewZJPXsGebXtZ/shqli9bTX3QgblIZBMCk4TIzTNiypKplZO58Usf5MP3fICtr9ez8k+vsXxdI3tb2zypz7eEwDkRTAjsjWmZoomIMOsdFcx6RwW3JhLUrqrj+b9uYMXGJo50Rsu4mF1QQmFRYdBhDBwjpuiTn5/PWe+p5qz3VPPx9k5effJ1Vj5Tx+qt+2gLicPUH/OjnBCYRBUS3i+BnQ1GTC5RNKSQC685jwuvOe+UI7jy+W28sutAWOZhnsbssVF38mxMyxRfUh3B5r2Hef63L7Pi7w3U7j8cdGg9iHJCYA+MmAYHYyePYcknLmPJJ2D31iZW/P5Vlr/aQH0IZlxEOiHwFGrcvMHItKop3Pj59/NhVd56bTsr//Q6y9c1su9ET0fQDydvtBQxcWZUEwJTUFBz0XbwIiKccU4lZ5xTyW2JBBue38zzf61l+eY9HOvo8iWG6qIIJwT2JiRmjxFTwOTn53P24gWcvXgBd7Z18MqTr/N0XRN/ObaTNrxzqaKeEHgKVbPUl+F0ioqLuGjJO7loCdx9pJW/PVXLE2/sYvnJ3SRcXp2+akIMphElMQaEoT+Gjx7Oez90Pu/lfMsRfGojf6rfySsd+10pv7Q0BteYbNS0TIZsGTt5DEtufjdLgMa3mlj5XB2/b2zgjURLzmWWL4hyQmAqZnWirBCRa4GvAHOB81R1Tf/viD/TZ03hxllT+LAqb67dzooXt/G7fTvYo9lb7dPzhjNyzAgPo/QRM9E1azYC/wT8d9CBhA0RYXZNJbNrKvmXRIINz9fx7NoGHmtuoIX2ft8b+YTAFBRQM50oM6paB8THwvUIyxGs5uzF1XyqrYNXnqnl6dpdfTqCc0bHZOYD2Gs8uDNmEpHLgPuAfOBnqvpNJ+8PtZicICJ3AHcAzJwZl/GAc4qKi7joqnO46KpzuPtIKy8+VctfejmCFRG9Q2BfqAvdPBHJB34EvBdoBF4VkT+r6uZsywhcTCLyLDA5zab/rap/yrYcVV0KLAWoqakJRyc6YIaPHs4lHzqfSzifQ02HWfX0Rv64vYHSqglBh+Yu7rRM5wFbVXU7gIg8ClwNZC0m0ZA4If0hIiuBz2ZrQIjIAcCNWweOBw66UE7QhPVzlKrqgJQtIk9hfb5MFAOp87aW2j/AyXI+CFymqrfbz28C3qmqd2UbS+AtkxcM9AQlEZE1qlrjRllBEpfPkQ5VvcylotINzB21NKFehFJElohII3AB8BcReTromAyxpRGYkfJ8OrDHSQGhbplU9THgsaDjMAwKXgVmiUg5sBu4DrjBSQGhFlMIWJp5l0gQl8/hGaraJSJ3AU9jWeMPqOomJ2VEwoAwGKJAqMdMBkOUMGIyGFzCiCkDInKtiGwSkW4RiZy9LCKXicgbIrJVRO4OOp44Y8SUmeRk21VBB+KUlCkylwPzgOtFZF6wUcUX4+ZlIOKTbQc8RcaQPaZlijfTgF0pzxvt1wweYFom3JtsG0IGPEXGkD1GTICqXhx0DB4x4Ckyhuwx3bx4c2qKjIgUYU2R+XPAMcUWI6YMRHmyrap2AckpMnXAb5xOkTFkj5lOZDC4hGmZDAaXMGIyGFzCiMlgcAkjJoPBJYyYDAaXMGIyGFzCiMlgcIn/D6/MQuj2xlmpAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.transforms import Affine2D\n", + "from matplotlib.ticker import MaxNLocator\n", + "from mpl_toolkits.axisartist.grid_helper_curvelinear import GridHelperCurveLinear\n", + "from mpl_toolkits.axisartist import Axes\n", + "import mpl_toolkits.axisartist.floating_axes as floating_axes\n", + "from mpl_toolkits.axisartist.grid_finder import MaxNLocator as MaxNLocatorGrid\n", + "\n", + "\n", + "def _get_extent(signal, axis0, axis1):\n", + " assert signal.shape == (axis0.size, axis1.size)\n", + " x0, x1 = axis1[[0, -1]]\n", + " y0, y1 = axis0[[0, -1]]\n", + " dx = (axis1[1] - axis1[0]) / 2\n", + " dy = (axis0[1] - axis0[0]) / 2\n", + " return x0 - dx, x1 + dx, y0 - dy, y1 + dy\n", + "\n", + "\n", + "def _get_transformed_extent(signal, axis0, axis1, inv_cof):\n", + " xmin, xmax, ymin, ymax = _get_extent(signal, axis0, axis1)\n", + " corners = [[xmin, ymin, 1], [xmax, ymin, 1], [xmin, ymax, 1], [xmax, ymax, 1]]\n", + " corners = numpy.array(corners).T\n", + " corners = inv_cof.dot(corners)\n", + " xmin = corners[0].min()\n", + " xmax = corners[0].max()\n", + " ymin = corners[1].min()\n", + " ymax = corners[1].max()\n", + " return xmin, xmax, ymin, ymax\n", + "\n", + "\n", + "def _imshow(ax, signal, axis0, axis1):\n", + " extent = _get_extent(signal, axis0, axis1)\n", + " im = ax.imshow(signal, extent=extent, aspect=\"equal\", origin=\"lower\")\n", + " ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n", + " ax.yaxis.set_major_locator(MaxNLocator(integer=True))\n", + " xmin, xmax, ymin, ymax = extent\n", + " ax.set_xlim(xmin, xmax)\n", + " ax.set_ylim(ymin, ymax)\n", + " return im\n", + "\n", + "\n", + "def plot_nxdata2d(signal, axis0, axis1, **kw):\n", + " plt.figure(**kw)\n", + " ax = plt.gca()\n", + " im = _imshow(ax, signal, axis0, axis1)\n", + " plt.colorbar(im)\n", + "\n", + "\n", + "def plot_nxdata2d_transform(signal, axis0, axis1, cof, **kw):\n", + " # https://matplotlib.org/stable/gallery/images_contours_and_fields/affine_image.html\n", + "\n", + " plt.figure(**kw)\n", + " ax = plt.gca()\n", + " im = _imshow(ax, signal, axis0, axis1)\n", + "\n", + " if cof is not None:\n", + " cof = numpy.array(cof)\n", + " inv_cof = numpy.linalg.inv(cof)\n", + " transform = Affine2D(inv_cof)\n", + " im.set_transform(transform + ax.transData)\n", + " lims = _get_transformed_extent(signal, axis0, axis1, inv_cof)\n", + " xmin, xmax, ymin, ymax = lims\n", + " ax.set_xlim(xmin, xmax)\n", + " ax.set_ylim(ymin, ymax)\n", + " plt.colorbar(im)\n", + "\n", + "\n", + "def plot_nxdata2d_tgrid(signal, axis0, axis1, cof, **kw):\n", + " # https://matplotlib.org/stable/gallery/axisartist/demo_curvelinear_grid.html\n", + "\n", + " cof = numpy.array(cof)\n", + " inv_cof = numpy.linalg.inv(cof)\n", + " transform = Affine2D(inv_cof)\n", + " grid_helper = GridHelperCurveLinear(\n", + " transform,\n", + " grid_locator1=MaxNLocatorGrid(integer=True),\n", + " grid_locator2=MaxNLocatorGrid(integer=True),\n", + " )\n", + "\n", + " fig = plt.figure(**kw)\n", + " ax = fig.add_subplot(111, axes_class=Axes, grid_helper=grid_helper)\n", + " im = _imshow(ax, signal, axis0, axis1)\n", + "\n", + " x = ax.new_floating_axis(nth_coord=0, value=0)\n", + " y = ax.new_floating_axis(nth_coord=1, value=0)\n", + " ax.axis[\"x\"] = x\n", + " ax.axis[\"y\"] = y\n", + " ax.grid(True, zorder=0)\n", + "\n", + " # x.label.set_color('white')\n", + " # y.label.set_color('white')\n", + " # ax.tick_params(axis='x', colors='white')\n", + " # ax.tick_params(axis='y', colors='white')\n", + " # x.spines['left'].set_color('white')\n", + " # y.spines['top'].set_color('white')\n", + "\n", + " plt.colorbar(im)\n", + "\n", + "\n", + "def plot_nxdata2d_floating(signal, axis0, axis1, cof, **kw):\n", + " # https://matplotlib.org/stable/gallery/axisartist/demo_floating_axes.html\n", + "\n", + " cof = numpy.array(cof)\n", + " inv_cof = numpy.linalg.inv(cof)\n", + " transform = Affine2D(inv_cof)\n", + "\n", + " grid_helper = floating_axes.GridHelperCurveLinear(\n", + " transform,\n", + " extremes=_get_extent(signal, axis0, axis1),\n", + " grid_locator1=MaxNLocatorGrid(integer=True),\n", + " grid_locator2=MaxNLocatorGrid(integer=True),\n", + " )\n", + "\n", + " fig = plt.figure(**kw)\n", + " ax = fig.add_subplot(\n", + " 111, axes_class=floating_axes.FloatingAxes, grid_helper=grid_helper\n", + " )\n", + "\n", + " aux_ax = ax.get_aux_axes(transform)\n", + "\n", + " im = _imshow(aux_ax, signal, axis0, axis1)\n", + "\n", + " plt.colorbar(im, ax=ax)\n", + "\n", + "\n", + "def plot_vector2d(ax, x0, y0, x1, y1, label):\n", + " norm = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5\n", + " ax.arrow(\n", + " x0,\n", + " y0,\n", + " x1 - x0,\n", + " y1 - y0,\n", + " color=\"white\",\n", + " width=norm * 0.01,\n", + " length_includes_head=True,\n", + " )\n", + " ax.text(x1, y1, label, color=\"white\")\n", + "\n", + "\n", + "def test_plotting():\n", + " kw = {\"figsize\": (5, 5)}\n", + "\n", + " # NXdata\n", + " n0, n1 = 2, 3\n", + " axis0 = numpy.arange(n0) / (n0 - 1)\n", + " axis1 = numpy.arange(n1) / (n1 - 1)\n", + " signal = numpy.arange(n0 * n1).reshape(n0, n1)\n", + "\n", + " # NXdata without reference frame\n", + " # The coordinates are given with respect to the plot basis\n", + " plot_nxdata2d(signal, axis0, axis1, **kw)\n", + " plt.gca().set_title(\"Data frame with data axes\")\n", + "\n", + " # NXdata with reference frame\n", + " # The coordinates are given with respect the data basis\n", + " # The change-of-frame matrix describes the data basis\n", + " # with respect to the plot basis\n", + " a = 10\n", + " cof = [[cos(a), -sin(a), 1], [sin(a), 0.5 * cos(a), 0], [0, 0, 1]]\n", + "\n", + " plot_nxdata2d_transform(signal, axis0, axis1, cof)\n", + " plt.gca().set_title(\"Plotting frame with plotting axes\")\n", + "\n", + " plot_nxdata2d_tgrid(signal, axis0, axis1, cof)\n", + " plt.gca().set_title(\"Data frame with data axes and plotting grid (TODO)\")\n", + "\n", + " plot_nxdata2d_floating(signal, axis0, axis1, cof)\n", + " plt.gca().set_title(\"Plotting frame with data axes\")\n", + "\n", + "\n", + "test_plotting()" + ] + }, + { + "cell_type": "markdown", + "id": "7abcf55b-aceb-4b47-b5fd-87be8ba08b8f", + "metadata": {}, + "source": [ + "## Saving\n", + "\n", + "Utilities for reading and writing NXdata" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "29719aa8-f8ef-413f-bd8a-2aa41fabbf23", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import tempfile\n", + "import h5py\n", + "\n", + "\n", + "def get_filename():\n", + " return os.path.join(tempfile.gettempdir(), \"nxdata_cof_example.h5\")\n", + "\n", + "\n", + "def save_nxdata(name, signal, axis0, axis1, title, cofxyz=None):\n", + " if cofxyz is None:\n", + " mode = \"w\"\n", + " else:\n", + " mode = \"a\"\n", + " with h5py.File(get_filename(), mode=mode) as root:\n", + " if cofxyz is None:\n", + " root.attrs[\"NX_class\"] = \"NXroot\"\n", + " root.attrs[\"default\"] = \"entry\"\n", + " entry = root.create_group(\"entry\")\n", + " entry.attrs[\"NX_class\"] = \"NXentry\"\n", + " else:\n", + " entry = root[\"entry\"]\n", + " data = entry.create_group(name)\n", + " entry.attrs[\"default\"] = \"name\"\n", + " data.attrs[\"NX_class\"] = \"NXdata\"\n", + " data.attrs[\"signal\"] = \"data\"\n", + " data.attrs[\"axes\"] = [axis0[\"name\"], axis1[\"name\"]]\n", + " data[\"title\"] = title\n", + " data[\"data\"] = signal\n", + " data[axis0[\"name\"]] = axis0[\"value\"]\n", + " data[axis1[\"name\"]] = axis1[\"value\"]\n", + " data[axis0[\"name\"]].attrs[\"long_name\"] = axis0[\"title\"]\n", + " data[axis1[\"name\"]].attrs[\"long_name\"] = axis1[\"title\"]\n", + " if cofxyz is not None:\n", + " data.attrs[\"passive_transformation\"] = \"cof\"\n", + " cofxy = numpy.identity(3)\n", + " cofxy[:2, :2] = cofxyz[:2, :2]\n", + " cofxy[:2, -1] = cofxyz[:2, -1]\n", + " data[\"cof\"] = cofxy\n", + "\n", + "\n", + "def plot_nxdata(name, figsize=(10, 10)):\n", + " with h5py.File(get_filename(), mode=\"r\") as root:\n", + " data = root[\"entry\"][name]\n", + " signal = data[data.attrs[\"signal\"]]\n", + " axis0 = data[data.attrs[\"axes\"][0]]\n", + " axis1 = data[data.attrs[\"axes\"][1]]\n", + "\n", + " cof_name = data.attrs.get(\"passive_transformation\")\n", + " if cof_name is None:\n", + " plot_nxdata2d(signal, axis0, axis1, figsize=(10, 10))\n", + " else:\n", + " cof = data[cof_name]\n", + " plot_nxdata2d_transform(signal, axis0, axis1, cof, figsize=figsize)\n", + " ax = plt.gca()\n", + " ax.set_title(data[\"title\"][()].decode())\n", + " ax.set_xlabel(axis1.attrs[\"long_name\"])\n", + " ax.set_ylabel(axis0.attrs[\"long_name\"])" + ] + }, + { + "cell_type": "markdown", + "id": "82a1d0f7-845d-4045-b8b0-fdc84c7ddf79", + "metadata": {}, + "source": [ + "# Examples\n", + "\n", + "## NXdata crystallography example\n", + "\n", + "Assume we measure a diffraction signal in reciprocal space with coordinates in HKL space and we want to plot the data in direct or reciprocal space." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6e7f34c2-59b9-4260-b956-86e7c7748da9", + "metadata": {}, + "outputs": [], + "source": [ + "# Lattice in direct space\n", + "lattice = {\"a\": 1, \"b\": 2, \"c\": 1, \"alpha\": 90, \"beta\": 90, \"gamma\": 120}" + ] + }, + { + "cell_type": "markdown", + "id": "c7e0f655-f146-48a4-a44f-9188cd4048cc", + "metadata": {}, + "source": [ + "Regular sampling grid in HKL space" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9fcac394-c7cd-4636-b169-e84dfa2b5dde", + "metadata": {}, + "outputs": [], + "source": [ + "haxis = numpy.linspace(-1.5, 1.5, 400)\n", + "kaxis = numpy.linspace(-1.5, 1.5, 400)\n", + "h, k = numpy.meshgrid(haxis, kaxis, indexing=\"xy\")\n", + "shape = h.shape\n", + "h = h.flatten()\n", + "k = k.flatten()\n", + "l = numpy.zeros_like(h)\n", + "HKL = numpy.stack([h, k, l], axis=1)" + ] + }, + { + "cell_type": "markdown", + "id": "963d9749-a9b9-4cea-986d-0e1edb998061", + "metadata": {}, + "source": [ + "NXdata axes and signal: diffraction signal with pixel axes" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bb6a4251-7ab9-458e-aa2d-d3a5d2056089", + "metadata": {}, + "outputs": [], + "source": [ + "# Laue conditions for diffraction\n", + "Q = 2 * numpy.pi * HKL\n", + "\n", + "# Number of unit cells in each direction\n", + "N = [3, 3, 3]\n", + "\n", + "signal = simplified_diffraction(Q, numpy.identity(3), N).reshape(shape)\n", + "\n", + "hmin = haxis[0]\n", + "dh = haxis[1] - haxis[0]\n", + "kmin = kaxis[0]\n", + "dk = kaxis[1] - kaxis[0]\n", + "\n", + "axis1 = (haxis - hmin) / dh\n", + "axis0 = (kaxis - kmin) / dk" + ] + }, + { + "cell_type": "markdown", + "id": "0c7c5d13-1dff-45e3-96ad-40ecea5dc75e", + "metadata": {}, + "source": [ + "Save NXdata with different passive transformations" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8e711dc9-5e8c-4fa6-837e-5c7c252c0e43", + "metadata": {}, + "outputs": [], + "source": [ + "axis0 = {\"name\": \"y\", \"value\": axis0}\n", + "axis1 = {\"name\": \"x\", \"value\": axis1}\n", + "\n", + "axis0[\"title\"] = \"Y (pixels)\"\n", + "axis1[\"title\"] = \"X (pixels)\"\n", + "save_nxdata(\"raw\", signal, axis0, axis1, \"Raw data frame\")\n", + "\n", + "cof_data_to_reciprocal = numpy.identity(4)\n", + "cof_data_to_reciprocal[0, -1] = -hmin / dh\n", + "cof_data_to_reciprocal[1, -1] = -kmin / dk\n", + "cof_data_to_reciprocal[0, 0] = 1 / dh\n", + "cof_data_to_reciprocal[1, 1] = 1 / dk\n", + "\n", + "axis0[\"title\"] = \"b*\"\n", + "axis1[\"title\"] = \"a*\"\n", + "save_nxdata(\n", + " \"reciprocal\",\n", + " signal,\n", + " axis0,\n", + " axis1,\n", + " \"Reciprocal frame\",\n", + " cofxyz=cof_data_to_reciprocal,\n", + ")\n", + "\n", + "B = busing_levy_reciprocal_basis(lattice)\n", + "cof_reciprocal_to_standard = numpy.identity(4)\n", + "cof_reciprocal_to_standard[:3, :3] = numpy.linalg.inv(B)\n", + "\n", + "cof_data_to_standard = cof_data_to_reciprocal.dot(cof_reciprocal_to_standard)\n", + "\n", + "axis0[\"title\"] = \"e1\"\n", + "axis1[\"title\"] = \"e0\"\n", + "save_nxdata(\n", + " \"standard\",\n", + " signal,\n", + " axis0,\n", + " axis1,\n", + " \"Standard Euclidean frame\",\n", + " cofxyz=cof_data_to_standard,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c5a3dacd-7894-479a-808b-84b41051dd29", + "metadata": {}, + "source": [ + "The final plot we want to show" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3b045c5c-4c80-406e-aa01-b790fee1911d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cofxyz = cof_data_to_standard\n", + "cofxy = numpy.identity(3)\n", + "cofxy[:2, :2] = cofxyz[:2, :2]\n", + "cofxy[:2, -1] = cofxyz[:2, -1]\n", + "\n", + "plot_nxdata2d_transform(signal, axis0[\"value\"], axis1[\"value\"], cofxy, figsize=(10, 10))\n", + "\n", + "ax = plt.gca()\n", + "ax.set_title(\"Standard Euclidean frame\")\n", + "ax.set_xlabel(\"e0\")\n", + "ax.set_ylabel(\"e1\")\n", + "\n", + "rlattice = lattice_to_reciprocal_lattice(lattice)\n", + "ra = rlattice[\"a\"]\n", + "rb = rlattice[\"b\"]\n", + "rab = rlattice[\"gamma\"]\n", + "\n", + "plot_vector2d(ax, 0, 0, ra, 0, \"(1, 0, 0)\")\n", + "plot_vector2d(ax, 0, 0, rb * cos(rab), rb * sin(rab), \"(0, 1, 0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "2d7d29fb-2f92-4189-9fb5-836cc7296cd1", + "metadata": {}, + "source": [ + "Plot data without transformation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "17640bb8-a30f-4009-9d95-0a93e5077dee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_nxdata(\"raw\")\n", + "\n", + "ax = plt.gca()\n", + "x0, y0, *_ = cof_data_to_reciprocal.dot([0, 0, 0, 1])[:2]\n", + "x1, y1, *_ = cof_data_to_reciprocal.dot([1, 0, 0, 1])[:2]\n", + "plot_vector2d(ax, x0, y0, x1, y1, \"(1, 0, 0)\")\n", + "x1, y1, *_ = cof_data_to_reciprocal.dot([0, 1, 0, 1])[:2]\n", + "plot_vector2d(ax, x0, y0, x1, y1, \"(0, 1, 0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "88d057d6-82b9-4833-8512-6562b21f1555", + "metadata": {}, + "source": [ + "Plot data in reciprocal space" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0b276d5c-cee2-4f81-90e8-8ea057661709", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_nxdata(\"reciprocal\")\n", + "\n", + "ax = plt.gca()\n", + "plot_vector2d(ax, 0, 0, 1, 0, \"(1, 0, 0)\")\n", + "plot_vector2d(ax, 0, 0, 0, 1, \"(0, 1, 0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "73cc023b-fdc5-49ba-b9cb-94c29f93a4d0", + "metadata": {}, + "source": [ + "Plot data in the standard Euclidean frame" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "60e1a684-91bc-40d3-85a4-ddb7a4d1c3f6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_nxdata(\"standard\", figsize=(10, 4))\n", + "\n", + "reciprocal_to_standard = numpy.identity(4)\n", + "reciprocal_to_standard[:3, :3] = B\n", + "\n", + "ax = plt.gca()\n", + "x0, y0, *_ = reciprocal_to_standard.dot([0, 0, 0, 1])[:2]\n", + "x1, y1, *_ = reciprocal_to_standard.dot([1, 0, 0, 1])[:2]\n", + "plot_vector2d(ax, x0, y0, x1, y1, \"(1, 0, 0)\")\n", + "x1, y1, *_ = reciprocal_to_standard.dot([0, 1, 0, 1])[:2]\n", + "plot_vector2d(ax, x0, y0, x1, y1, \"(0, 1, 0)\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nexus", + "language": "python", + "name": "nexus" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt index 6d024bda3a..5ad6361f1e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,6 +5,8 @@ pyyaml # Documentation building sphinx>=5 sphinx-tabs +nbsphinx +ipython # Testing pytest