pytxs 0.0.1__py3-none-any.whl

pytxs-0.0.1.dist-info/LICENSE.rst

@@ -0,0 +1,32 @@
+License
+===============================================================================
+
+txs
+-------------------------------------------------------------------------------
+
+txs is available under the `MIT License`_::
+
+  txs: time-resolved x-ray scattering/spectroscopy data analysis tools
+
+  Copyright (C) 2021-2022 ESRF - The European Synchrotron, Grenoble, France
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+
+.. _MIT License: http://opensource.org/licenses/MIT
+

pytxs-0.0.1.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: pytxs
+Version: 0.0.1
+Summary: time-resolved x-ray scattering
+Author-email: Matteo Levantino <matteo.levantino@esrf.fr>
+License: MIT
+Project-URL: Homepage, https://gitlab.esrf.fr/levantin/txs
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: numpy >=1.10
+Requires-Dist: h5py >3.0
+Requires-Dist: tqdm
+Requires-Dist: fabio
+Requires-Dist: pyFAI
+Requires-Dist: xraydb >=4.3.4
+Requires-Dist: datastorage
+Provides-Extra: gui
+Requires-Dist: PyQt5 ; extra == 'gui'
+Requires-Dist: matplotlib ; extra == 'gui'
+Requires-Dist: silx ; extra == 'gui'
+
+====
+txs
+====
+
+**txs** is a free and open-source python package for the analysis
+of time-resolved x-ray scattering/spectroscopy data. 
+
+
+GETTING txs
+------------
+
+You can run txs on all major platforms. For download and installation:
+
+.. code-block:: bash
+
+    pip install git+https://gitlab.esrf.fr/levantin/txs.git
+
+For installing a specific version (e.g. version 0.1.0):
+
+.. code-block:: bash
+
+    pip install git+https://gitlab.esrf.fr/levantin/txs.git@0.1.0
+
+For upgrading txs to the last version/commit:
+
+.. code-block:: bash
+
+    pip install --upgrade git+https://gitlab.esrf.fr/levantin/txs.git
+
+For forcing the reinstallation of all packages (including dependencies):
+
+.. code-block:: bash
+
+    pip install --force-reinstall git+https://gitlab.esrf.fr/levantin/txs.git
+
+
+DOCUMENTATION
+-------------
+
+* Homepage: https://levantin.gitlab-pages.esrf.fr/txs
+* Quick guide: https://confluence.esrf.fr/display/ID09KB/txs+Python+package
+
+
+SOURCE CODE
+-----------
+
+* Source code: https://gitlab.esrf.fr/levantin/txs
+
+
+LICENSE
+-------
+
+txs is available under MIT License. See LICENSE.rst for more details.
+

pytxs-0.0.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+txs/__init__.py,sha256=aRMc_eJxijiNFiy0u7VplghfAUncgUsMVPTXDhAryCk,1457
+txs/_version.py,sha256=13MjurOXftVhyioV1vByi3NsQEgvDtYwQRlv4qTa3nY,497
+txs/azav.py,sha256=8z_yCgwQdFaok_wcVokVPN468ArLS8sSanvcMpDT7-I,37884
+txs/common.py,sha256=59Zlxnzpk8CoqtwTQZY1ImTN8DIpGQD5I8PyzS6hwwc,1153
+txs/corr.py,sha256=z488Ju8eew8vkVczv9zGzmy3t1sUttmHkHbMJZ_-pMw,3723
+txs/datared.py,sha256=FHmuAAp8SpXU5Dlhy9jFc2UrtbMraWN1WGNfWRemHtE,29478
+txs/datasets.py,sha256=UhIifqBfiXIVM4T6Tjl8mW1rBdN7NAcc8TQvzrh3KMA,36195
+txs/heating.py,sha256=Km49Bb8zamY6W-UbO7l0S_d35UMbB1soPwq6sIMSF3g,8697
+txs/live.py,sha256=NbVKXXY9rF8B4eAVo70SceLa5IjVTFtobILAbwNm_bM,14246
+txs/plot.py,sha256=uqLnYUJZAkf0jvQJFDl0GzgggzbWVL9HZkb7AhQs2sk,38276
+txs/utils.py,sha256=wAL49Gn4kD78Kj1LxZlCGurD0TyKQaCNPr--edk66PA,24921
+txs/xes.py,sha256=xmRmPNC3KpOojoKfSvHJctIEv5GHxdd3zKwD0enZ5NA,435
+txs/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+txs/analysis/plot.py,sha256=3TAjUDg1H2ElTgkB4Efcq1acjnHtkbhZwe5unLP0-y0,9185
+txs/analysis/svd.py,sha256=zqNjfnwWoQ2ZDco6v1lSFEiOP9UHD9IM8k3Stf3UcAI,11185
+txs/analysis/utils.py,sha256=sGv8V1Nr4phjWMAg3gKiBK20oyVoLckJWIIpMlO9uq4,16120
+txs/app/MainWindow.py,sha256=CNJRBVDhLk5xsmEsmFjKi00e0oY2mH10PCsqGve2u-Q,17566
+txs/app/PlotBase.py,sha256=KGEdZwUekcOAsduNUnouDI3Fe5pHKEOqEMGH5dF_OME,2975
+txs/app/PlotHeatmap.py,sha256=ynPgfpjcxXCzmaH_p1QGtWffe4OuaZGTC6j0YkIfsLo,4955
+txs/app/ProcessWorker.py,sha256=TUvqVjCPoZEyENdflriSvmiZr5oL1els6im8aRxZn3s,4338
+txs/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+txs/app/__main__.py,sha256=59vhADpUuAWIHBWcZQyBnAIyl1P-h5MhxlsQ361H5WE,2797
+txs/app/actions.py,sha256=1kpE10zlGN4l5qXkwi0KkkJYSTHYTVXw8aNvtLyjzcI,2484
+txs/app/mainwindow.ui,sha256=TmFp5rFMjG_X1Qe2SzUfOGMFjVtcS_aFSqxk4sTzhLQ,77252
+txs/app/plot.py,sha256=waxkfpAujFrsO0lr9oH2ytm5u28l_C9gz5V1ELnCKzo,15242
+txs/app/utils.py,sha256=unsaBA1kokkHQqK3Pp12tFuAvQ8kAuZfR_cvm5ivaSc,1334
+txs/app/widgets.py,sha256=mQ9J9gtfu5sUfZo6clw3e6WxoqsubmXZ_tsCavgK4CM,1972
+txs/app/tests/test_ProcessWorker.py,sha256=BGMUQm5XX4xNpxvS56yEMjpo986yx7Yqyorbg_3FyGQ,1350
+txs/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+txs/detectors/jungfrau.py,sha256=IqCK_-mFc-ft7Csv9K96OYI1Cf97nnRVAwEnVoISkAA,21651
+txs/tests/conftest.py,sha256=piMAb-m9pMnCEYF8nDDBBQRqHt5K76HnXIa4S3yRT-U,699
+txs/tests/test_azav.py,sha256=3WyTIXzHONZe2mpDkUAK4paVhrYbKOWTIbNqDqEDDRE,2709
+txs/tests/test_corr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+txs/tests/test_datared.py,sha256=pP7Ktqeb8KvEECmPJTdKctMJ2aYny_0jEPuU_YrCvJY,675
+txs/tests/test_datasets.py,sha256=2pIzrVttaG05CvFO3eYVN5nxLtQ1g8KWrhgcXDL1VM8,1500
+txs/tests/test_utils.py,sha256=GNz3exN8HNwgYiI8SC2aCkb3fly6QSu3gJ6K2Jm21Vk,266
+pytxs-0.0.1.dist-info/LICENSE.rst,sha256=TjMCSzUOzPc2_eHVGsz5iLgLwdVF0HIbIxR8NIEAmmM,1475
+pytxs-0.0.1.dist-info/METADATA,sha256=5pbh1wYVhNM_pKFAuyA1l5qBSkhMptKDGfMGDV9kwE4,1927
+pytxs-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+pytxs-0.0.1.dist-info/entry_points.txt,sha256=ZwQuA3S9N1-Tt_gxbYQrQmYSjKTlyw3SDdOrDIIPyzM,76
+pytxs-0.0.1.dist-info/top_level.txt,sha256=Wg1zaJITs9A4ZjNCgE5PhTSrNAtfjIcL3uZwCvgWWKA,4
+pytxs-0.0.1.dist-info/RECORD,,

pytxs-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytxs-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[gui_scripts]
+txs = txs.app.__main__:main
+txs2 = txs.app.__main__:main_txs2

pytxs-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+txs

txs/__init__.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""..."""
+
+__author__ = "Matteo Levantino"
+__contact__ = "matteo.levantino@esrf.fr"
+__licence__ = "MIT"
+__copyright__ = "ESRF - The European Synchrotron, Grenoble, France"
+__date__ = "01/09/2021"
+
+import xraydb as _xraydb
+
+
+def _init_xraydb():
+    """Add extra materials to xraydb user config file"""
+    extra_materials = (  # name, formula, density, category
+        ("gallium nitride", "GaN", 6.15, "semiconductor"),
+        ("epoxy", "C21H25ClO5", 1.2, "polymer"),
+        ("zirconium", "Zr", 6.52, "metal"),
+        ("gadox", "Gd2O2S", 4.3, "scintllator"),
+    )
+
+    for name, formula, density, category in extra_materials:
+        material = _xraydb.find_material(name)
+        if (
+            material is None
+            or material.formula != formula
+            or material.density != density
+            or category not in material.categories
+        ):
+            _xraydb.add_material(name, formula, density, [category])
+
+
+_init_xraydb()
+
+
+from . import utils
+from . import azav
+from . import datared
+from . import live
+from . import corr
+from . import plot
+from . import heating
+from .common import *
+from .datasets import load_images, BlissDataset
+from .azav import integrate1d_dataset as int1d_dset
+from .datared import datared as dred
+from .live import ana
+from .corr import get_density, get_mu
+from .plot import *
+from .utils import get_ai
+
+from . import _version
+__version__ = _version.get_versions()['version']

txs/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2024-09-30T14:35:16+0200",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "5e98522f4c9f73d9c61d4e73ed903db1589ef9e7",
+ "version": "0.0.1"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

txs/analysis/plot.py

@@ -0,0 +1,299 @@
+"""Plotting functions to ease the analysis process.
+
+.. warning::
+    These functions make use of ipywidgets and are meant to be used within a
+    Jupyter notebook with the 'magic' `%matplotlib widget`.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.cm import get_cmap
+from ipywidgets import widgets
+
+from txs.heating import remove_heating
+from txs.utils import str2t
+from txs.analysis.utils import sort_delays
+from txs.analysis.svd import SVD
+
+
+def plot_dataset(
+        data, 
+        sample_names, 
+        heating=None, 
+        heating_qlim=(1.6, 2), 
+        q_scaled=False
+):
+    """Plot the processed data for each time delays."""
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    incr = 0.001
+    ylabel = 'q' if q_scaled else ''
+
+    delays = {}
+    for s_idx, sample in enumerate(data):
+        for _, delay in enumerate(sample['t']):
+            if delay not in delays:
+                delays[delay] = []
+            delays[delay].append(s_idx)
+
+    delay_slider = widgets.IntSlider( 
+        min=0, max=len(delays.keys()) - 1, value=0, step=1, description="delay" 
+    )
+
+    cmap = get_cmap('tab10')
+
+    @widgets.interact(delay=delay_slider)
+    def update_plot(delay):
+        ax.clear()
+
+        t_key = list(delays.keys())[delay]    
+
+        for idx, s_idx in enumerate(delays[t_key]):
+            q = data[s_idx]['q']
+            q_scale = q if q_scaled else np.ones_like(q)
+
+            t_idx = list(data[s_idx]['t']).index(t_key)
+            ax.errorbar(
+                q,
+                q_scale * data[s_idx]['diff_av'][:, t_idx] + idx * incr,
+                label=sample_names[s_idx],
+                color=cmap(idx),
+                alpha=0.4 if heating is not None else 1,
+            )
+
+            if heating is not None:
+                red2 = remove_heating(
+                    data[s_idx], heating, qlim=heating_qlim, verbose=False
+                )
+                ax.errorbar(
+                    q,
+                    q_scale * red2['diff_av'][:, t_idx] + idx * incr,
+                    color=cmap(idx),
+                )
+
+            ax.axhline(idx * incr, ls=":", alpha=0.2)
+
+        ax.set_xlabel("q [$\\rm \AA^{-1}$]")
+        ax.set_ylabel(f"{ylabel}S(q)")
+        ax.legend(loc=2, bbox_to_anchor=(1, 1))
+        ax.set_title(
+            f"$\\rm \Delta t$ = {t_key}\n" +
+            "semi-transparent -> " if heating is not None else "" +
+            "no heating removal" if heating is not None else ""
+        )
+
+        ax.relim()
+        ax.autoscale_view()
+        fig.tight_layout()
+
+    update_plot(0)
+
+
+def plot_svd_analysis(
+        data, 
+        heating=None, 
+        heating_qlim=(1.8, 2), 
+        q_scaled=False,
+        include_ref=False,
+        figsize=(10, 10),
+        plot_grid=None,
+        ref_delays=None,
+):
+    """Performs and plot a SVD analysis on the provided data."""
+    if heating is not None:
+        data = remove_heating(data, heating, qlim=heating_qlim, verbose=False)
+
+    q = data['q']
+    q_scale = q if q_scaled else np.ones_like(q)
+    ylabel = "q" if q_scaled else ""
+
+    data = sort_delays(data, ref_delays=ref_delays, include_ref=include_ref)
+
+    t = str2t(data['t'])
+
+    svd = SVD(data['diff_av']).run()
+
+    fig = plt.figure(figsize=figsize)
+    ax = []
+    if plot_grid is None:
+        gs = plt.GridSpec(3, 2, height_ratios=(1, 1, 1))
+    else:
+        gs = plot_grid
+    ax.append(fig.add_subplot(gs[0, :]))
+    ax.append(fig.add_subplot(gs[1, :], sharex=ax[0]))
+    ax.append(fig.add_subplot(gs[2, 0]))
+    ax.append(fig.add_subplot(gs[2, 1]))
+    cursor = Cursor(ax[:2])
+    cmap = get_cmap('gnuplot')
+
+    svd_rank = widgets.IntSlider(
+        min=0,
+        max=10,
+        step=1,
+        value=0,
+        description="svd rank",
+    )
+
+    incr_slider = widgets.FloatSlider( 
+        min=0, max=0.01, value=0.0005, step=0.0002, description="increment" 
+    )
+
+    leg_lines = {}
+    def on_pick(event):
+        legline = event.artist
+        for line in leg_lines[legline]:
+            visible = not line.get_visible()
+            line.set_visible(visible)
+        legline.set_alpha(1.0 if visible else 0.2)
+
+    @widgets.interact(rank=svd_rank, incr=incr_slider)
+    def update_plot(rank, incr, keep_lims=True):
+        ax0_lims = (ax[0].get_xlim(), ax[0].get_ylim())
+        ax1_lims = (ax[1].get_xlim(), ax[1].get_ylim())
+        ax[0].clear()
+        
+        correlations = svd.autocorr()
+        if rank == 0:
+            rank = np.arange(correlations[0].size)[correlations[0] > 0.5]
+
+        lines = []
+        leg_lines.clear()
+        for idx, val in reversed(list(enumerate(data['diff_av'].T))):
+            line_group = []
+            line = ax[0].plot(
+                data['q'],
+                q_scale * val + incr * idx,
+                # savgol_filter(val, 15, 3) + incr * idx,
+                color=cmap(idx / data['diff_av'].shape[1]),
+                alpha=0.4
+            )
+            line_group.append(line[0])
+
+            line = ax[0].plot(
+                data['q'],
+                q_scale * svd.recompose(rank)[:, idx] + incr * idx,
+                # savgol_filter(svd.recompose(rank)[:, idx], 15, 3) + incr * idx,
+                color=cmap(idx / data['diff_av'].shape[1]),
+                label=data['t'][idx],
+                ls='--'
+            )
+            line_group.append(line[0])
+            line = ax[0].axhline(incr * idx, color='black', ls=':', alpha=0.2)
+            line_group.append(line)
+        
+            lines.append(line_group)
+
+        ax[0].set_xlabel("q [$\\rm \AA^{-1}$]")
+        ax[0].set_ylabel(f'$\\rm {ylabel}\Delta S(q)$ ')
+        ax[0].grid(alpha=0.2)
+        if keep_lims:
+            ax[0].set_xlim(ax0_lims[0])
+            ax[0].set_ylim(ax0_lims[1])
+        leg = ax[0].legend(loc=2, bbox_to_anchor=(1, 1), fontsize=10)
+
+        for legline, origlines in zip(leg.get_lines(), lines):
+            legline.set_picker(True)
+            legline.set_pickradius(10)
+            leg_lines[legline] = origlines
+
+        patterns = svd.patterns(rank)
+        ax[1].clear()
+        for idx, val in enumerate(patterns[0].T):
+            ax[1].plot(
+                data['q'],
+                q_scale * val + incr * idx,
+                # savgol_filter(val, 15, 3) + incr * idx
+            )
+            ax[1].axhline(incr * idx, color='black', ls=':', alpha=0.2)
+        ax[1].set_xlabel("q [$\\rm \AA^{-1}$]")
+        ax[1].set_ylabel(f'{ylabel}U vectors\n[arb. units]')
+        ax[1].grid(alpha=0.2)
+        if keep_lims:
+            ax[1].set_xlim(ax1_lims[0])
+            ax[1].set_ylim(ax1_lims[1])
+        ax[1].autoscale_view()
+
+        ax[2].clear()
+
+        # patterns = patterns[1].T / np.max(np.abs(patterns[1])) + 0.5
+        patterns = patterns[1].T
+        ax[2].plot(
+            t,
+            patterns,
+        )
+        ax[2].set_xlabel('time')
+        ax[2].set_ylabel('V vectors\n[arb. units]')
+        # ax[2].set_xticklabels(delays, rotation=-45, ha='left')
+        ax[2].grid(alpha=0.2)
+        ax[2].axhline(0, color='black', ls=':')
+        ax[2].relim()
+        ax[2].autoscale_view()
+
+        ax[3].clear()
+        ax[3].plot(correlations[0], marker='o', label='U vectors')
+        ax[3].plot(correlations[1], marker='^', label='V vectors')
+        ax[3].axhline(0.5, color='black', ls=':')
+        ax[3].set_xlabel('rank')
+        ax[3].set_ylabel('autocorrelations\n[arb. units]')
+        ax[3].grid(alpha=0.2)
+        ax[3].relim()
+        ax[3].autoscale_view()
+        ax[3].legend(loc=2, bbox_to_anchor=(1, 1))
+
+        cursor.drawline()
+
+    update_plot(0, 0.0005, False)
+
+    fig.tight_layout()
+    fig.canvas.mpl_connect('motion_notify_event', cursor.on_mouse_move)
+    fig.canvas.mpl_connect('button_press_event', cursor.on_mouse_press)
+    fig.canvas.mpl_connect('pick_event', on_pick)
+
+    return data, svd
+
+
+class Cursor:
+    """A vertical line cursor."""
+    def __init__(self, ax):
+        if not isinstance(ax, list):
+            ax = [ax]
+        self.ax = ax
+        self.vertical_line = []
+        self.persistent_lines = []
+
+        self.drawline()
+
+    def drawline(self):
+        self.vertical_line = [
+            val.axvline(color='k', lw=0.8, ls='--', alpha=0.6) 
+            for val in self.ax
+        ]
+
+    def on_mouse_move(self, event):
+        if not event.inaxes:
+            for line in self.vertical_line:
+                line.set_visible(False)
+            pass
+        else:
+            for line in self.vertical_line:
+                line.set_visible(True)
+            x = event.xdata
+            # update the line positions
+            for idx, val in enumerate(self.ax):
+                self.vertical_line[idx].set_xdata([x])
+                # val.figure.canvas.draw()
+
+    def on_mouse_press(self, event):
+        if not event.inaxes:
+            pass
+        else:
+            x = event.xdata
+            side = event.button
+            if side == 1:
+                for val in self.ax:
+                    line = val.axvline(x, color='k', lw=0.8, ls='--', alpha=0.6)
+                    self.persistent_lines.append(line)
+            if side == 3:
+                for line in self.persistent_lines:
+                    line.remove()