SusMat-SWAXS 2.1.3__py3-none-any.whl

smswaxs/__init__.py

@@ -0,0 +1,32 @@
+"""
+SusMat-SWAXS: A collection of python scripts for SWAXS data processing and conversion.
+
+This package provides tools for:
+- SAXS/WAXS data integration from Xenocs Xeuss instruments
+- Data format conversions (EDF to HDF5, TIFF, etc.)
+- Background subtraction and absorption corrections
+- Data visualization and analysis
+"""
+
+__version__ = "2.1.3"
+__author__ = "Samuel Eyley"
+__email__ = "samuel.eyley@kuleuven.be"
+
+# Import CLI functions for programmatic access
+from .dat_conv import cli as dat_conv_cli
+from .xeuss_edf_h5_multi import add_edfs_to_hdf5
+from .saxs_integration_xeuss import cli as saxs_integration_cli
+from .waxs_integration_xeuss import cli as waxs_integration_cli
+from .sph_harm import cli as sph_harm_cli
+
+# Make CLI functions available at package level
+__all__ = [
+    "__version__",
+    "__author__", 
+    "__email__",
+    "dat_conv_cli",
+    "add_edfs_to_hdf5", 
+    "saxs_integration_cli",
+    "waxs_integration_cli",
+    "sph_harm_cli"
+]

smswaxs/dat_conv.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May  7 11:44:10 2015
+
+@author: u0092172
+"""
+import argparse as ap
+import re
+import numpy as np
+
+def get_line_number(phrase, file_name):
+    """Get the line number containing phrase"""
+    with open(file_name, encoding="utf-8") as f:
+        for i, line in enumerate(f, 1):
+            p = re.compile(phrase)
+            if p.match(line) is not None:
+                return i
+
+def get_number_lines(file_name):
+    """Get the number of lines in a file"""
+    with open(file_name, encoding="utf-8") as f:
+        lines = len(f.readlines())
+        return lines
+
+
+def cli():
+    """Convert dat files to xye format for use in TOPAS"""
+    parser = ap.ArgumentParser(description='Convert dat files to xye format for use in TOPAS')
+    parser.add_argument("input", help="Filename of the .dat (excl. ext.)")
+    parser.add_argument(
+        "--wavelength", help="Wavelength in Angstroms", default=float(1.54189))
+    parser.add_argument(
+        "--highscore", help="Output for highscore plus", action="store_true")
+    parser.add_argument(
+        "--exposure", help="Counting time (convert to counts from CPS)", type=float, default=1)
+    # parser.add_argument("--dat", help="convert from dat file", action="store_true")
+    parser.add_argument(
+        "--SAXS", help="output SAXS data (q and don't cut low angle)", action="store_true")
+    parser.add_argument(
+        "--renormalize", help="boost counts", action="store_true")
+    parser.add_argument("--clip", help="clip range", action="store_true")
+    parser.add_argument(
+        "--fullprof", help="general fullprof input", action="store_true")
+    parser.add_argument(
+        "--kratky", help="Generate Kratky plot columns", action="store_true")
+    parser.add_argument("--pyfai", help="pyfai input", action="store_true")
+    parser.add_argument(
+        "--zero", help="set minimum to zero", action="store_true")
+    args = parser.parse_args()  # map arguments to args
+
+    fname = args.input
+    if args.highscore is True:
+        ext = ".asc"
+    elif args.fullprof is True:
+        ext = "_FP.dat"
+    elif args.kratky is True:
+        ext = "_kratky.dat"
+    else:
+        ext = ".xye"
+
+    # Import the data
+
+    if args.kratky is True:
+        args.SAXS = True
+
+    if args.pyfai is True:
+        data = np.genfromtxt(fname, comments='#',
+                             usecols=(0, 1, 2), encoding="utf-8")
+    else:
+        head = get_line_number('.*q\\([AÅ].*', fname)
+        data = np.genfromtxt(fname, skip_header=head,
+                             usecols=(0, 1, 2), encoding="utf-8")
+
+    data = data[~np.isnan(data).any(axis=1)]
+
+    q = data[:, 0]
+    i = data[:, 1]
+    e = data[:, 2]
+
+    if args.pyfai is True:
+        ttheta = q
+        if args.clip is True:
+            start = np.where(ttheta > 5)[0][0]
+            ttheta = ttheta[start:]
+            i = i[start:]
+            e = e[start:]
+    elif args.SAXS is False:
+        # Calc 2theta
+
+        ttheta = 2*np.degrees(np.arcsin((q*args.wavelength)/(4*np.pi)))
+
+        # Clip the data to start at 5 degrees to remove excessive intensity
+        if args.clip is True:
+            start = np.where(ttheta > 5)[0][0]
+            ttheta = ttheta[start:]
+            i = i[start:]
+            e = e[start:]
+
+        # Convert i to counts
+    if args.renormalize is True:
+        i = i*args.exposure*1e11
+    else:
+        i = i*args.exposure
+
+    if min(i) < 0:
+        i -= min(i)
+
+    if args.zero is True:
+        i -= min(i)
+
+    if args.highscore is True:
+        out = np.column_stack((ttheta.flatten(), i.flatten()))
+    else:
+        if args.SAXS is False:
+            out = np.column_stack((ttheta.flatten(), i.flatten(), e.flatten()))
+        elif args.kratky is False:
+            out = np.column_stack((q.flatten(), i.flatten(), e.flatten()))
+        else:
+            q2i = (q**2)*i
+            q2sig = (q**2)*e
+            out = np.column_stack(
+                (q.flatten(), i.flatten(), q2i.flatten(), e.flatten(), q2sig.flatten()))
+
+    if args.fullprof is True:
+        head2 = 'XYDATA' + '\n' + 'INTER 0 0 2' + 4*'\n'
+    elif args.kratky is True:
+        head2 = "q I(q) q2I(q) sig(q) q2sig(q)"
+    else:
+        head2 = ''
+
+    np.savetxt(fname[:-4]+ext, out, delimiter=' ', fmt='%.10f',
+               header=head2, comments='', newline='\n')
+
+
+if __name__ == '__main__':
+    cli()

smswaxs/saxs_integration.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""
+Spyder Editor
+
+This is a temporary script file.
+"""
+
+import h5py
+import hdf5plugin
+import pyFAI
+import fabio
+import numpy as np
+import os
+import glob
+import matplotlib.pyplot as plt
+from matplotlib.colors import LogNorm
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+import matplotlib.ticker as ticker
+import argparse as ap
+
+parser = ap.ArgumentParser(description=
+                           "Perform data reduction on hdf5 data from DESY")
+
+parser.add_argument("sample", help="sample file (.nxs)")
+
+parser.add_argument("mask", help="mask file (.edf)")
+parser.add_argument("poni", help="PONI configuration file (.poni)")
+parser.add_argument("--empty", help="empty file (.nxs)")
+parser.add_argument("--background", help="background file (.nxs)")
+
+parser.add_argument("--bkg_factor", help="background correction factor",type=float,default=float(1))
+parser.add_argument("--noscaling", help="background file (.nxs)",action="store_true")
+parser.add_argument("--autobkg", help="Automatic background scaling",action="store_true")
+args = parser.parse_args()
+
+#path = "/home/u0092172/Documents/"
+#folder = "DESY/"
+#sample = "GA5/GA5_2.nxs"
+#background = "water/water_2.nxs"
+mask = fabio.open(args.mask)
+poni = pyFAI.load(args.poni)#"config_saxs_sdetx_1500_12keV.poni")
+file = h5py.File(args.sample,'r')
+
+if args.noscaling == True:
+    transmission_sample = 1
+else:
+    transmission_sample = file['scan']['data']['beamstop_2'][()]/file['scan']['data']['ic1'][()]
+print("Sample transmission:"+str(round(transmission_sample,4)))
+
+temperature = str(round(file['scan']['data']['p62']['t95tempproglinkam']['eh.01']['temperature'][()],2))
+print("Sample temperature:"+temperature)
+
+
+data_1D = poni.integrate1d(file['scan']['data']['saxs_raw'][()][0]/transmission_sample,
+                           1000, filename=args.sample+"_"+temperature+'_1D.dat', correctSolidAngle=True,
+                                  method='csr_ocl', radial_range=(None), azimuth_range=(None),
+                                  unit="q_A^-1", mask=mask.data, normalization_factor=1.0,
+                                  metadata=None,error_model="poisson") 
+
+if args.background != None:
+    bkg = h5py.File(args.background,'r')
+    if args.noscaling == True:
+        transmission_bkg = 1
+    else:
+        transmission_bkg = bkg['scan']['data']['beamstop_2'][()]/bkg['scan']['data']['ic1'][()]
+    try:
+        temperature_bkg = str(round(bkg['scan']['data']['p62']['t95tempproglinkam']['eh.01']['temperature'][()],2))
+    except KeyError:
+        temperature_bkg = str(-1000)
+    print("Background transmission:"+str(round(transmission_bkg,4)))
+    print("Background temperature:"+temperature_bkg)
+    
+    bkg_1D = poni.integrate1d(bkg['scan']['data']['saxs_raw'][()][0]/transmission_bkg,
+                              1000, filename=args.sample+"_"+temperature+'_bkg1D.dat', correctSolidAngle=True,
+                                  method='csr_ocl', radial_range=(None), azimuth_range=(None),
+                                  unit="q_A^-1", mask=mask.data, normalization_factor=1.0,
+                                  metadata=None,error_model="poisson")
+    if args.autobkg == True:
+        print("Use automated background scaling with caution!")
+        if max(bkg_1D[1][:np.where(bkg_1D[0]>0.02)[0][0]]) > max(data_1D[1][:np.where(data_1D[0]>0.02)[0][0]]):
+            bkg_1D = [bkg_1D[0],bkg_1D[1],bkg_1D[2]]
+            bkg_1D[1] -=  max(bkg_1D[1][:np.where(bkg_1D[0]>0.02)[0][0]]) - max(data_1D[1][:np.where(data_1D[0]>0.02)[0][0]])
+else:
+    data_I = data_1D[1]
+    data_sig = abs(data_1D[2])
+if args.empty != None:
+    empty = h5py.File(args.empty,'r')
+    if args.noscaling == True:
+        transmission_empty = 1
+    else:
+        transmission_empty = empty['scan']['data']['beamstop_2'][()]/empty['scan']['data']['ic1'][()]
+    empty_1D = poni.integrate1d(empty['scan']['data']['saxs_raw'][()][0]/transmission_empty,
+                              1000, filename=args.sample+"_"+temperature+'_empty1D.dat', correctSolidAngle=True,
+                                  method='csr_ocl', radial_range=(None), azimuth_range=(None),
+                                  unit="q_A^-1", mask=mask.data, normalization_factor=1.0,
+                                  metadata=None,error_model="poisson")
+    if args.autobkg == True:
+        if max(empty_1D[1][:np.where(empty_1D[0]>0.02)[0][0]]) > max(data_1D[1][:np.where(data_1D[0]>0.02)[0][0]]):
+            empty_1D[1] -= max(empty_1D[1][:np.where(empty_1D[0]>0.02)[0][0]]) - max(data_1D[1][:np.where(data_1D[0]>0.02)[0][0]])
+    if args.background != None:
+        data_I = (data_1D[1]-empty_1D[1])-(bkg_1D[1]-empty_1D[1])
+        data_sig = abs(data_1D[2])+abs(empty_1D[2])+abs(bkg_1D[2])+abs(empty_1D[2])
+    else:
+        data_I = data_1D[1]-empty_1D[1]
+        data_sig = abs(data_1D[2])+abs(empty_1D[2])
+else:
+    if args.background == None:
+        data_I = data_1D[1]
+        data_sig = abs(data_1D[2])
+    else:
+        data_I = data_1D[1]-bkg_1D[1]
+        data_sig = abs(data_1D[2])+abs(bkg_1D[2])
+fig, ax = plt.subplots(figsize=(25,10),constrained_layout=True)
+"""fig1 = ax[0].imshow(data_cor,norm=LogNorm(vmin=1e-1, vmax=10**3),cmap=plt.get_cmap('plasma'))
+# fig1 = ax[0].imshow(data_cor,norm=LogNorm(vmin=300, vmax=10**5),cmap=plt.get_cmap('plasma'))
+# create an axes on the right side of ax. The width of cax will be 5%
+# of ax and the padding between cax and ax will be fixed at 0.05 inch.
+divider = make_axes_locatable(ax[0])
+cax = divider.append_axes("right", size="5%", pad=0.05)
+
+cbar = plt.colorbar(fig1, cax=cax)
+cbar.ax.tick_params(labelsize=25)
+
+ax[0].set_xlabel('pixel',fontsize=25)
+ax[0].set_ylabel('pixel',fontsize=25)
+ax[0].tick_params(labelsize=25)
+"""
+# fig2 = ax.plot(q, Intensity)
+#fig2 = ax.plot(data_1D[0],data_I)
+fig = ax.errorbar(data_1D[0],data_I,yerr=data_sig)
+ax.set_xscale('log')
+ax.set_yscale('log')
+ax.set_xlabel(r'$Q\/[\AA^{-1}]$',fontsize=25)
+ax.set_ylabel('intensity [a.u.]',fontsize=25)
+# ax.set_xticks([0.01,0.1,0.4,0.6])
+ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())
+ax.tick_params(labelsize=25)
+#plt.show()
+plt.savefig(args.sample+"_"+temperature+".png", bbox_inches="tight", dpi=600)
+
+data_out = np.column_stack((data_1D[0],data_I,data_sig))
+np.savetxt(args.sample+"_subtracted.dat",data_out,delimiter='\t',fmt='%s')

smswaxs/saxs_integration_xeuss.py

@@ -0,0 +1,225 @@
+"""
+This script will integrate 2D SAXS data collected on the Xenocs
+Xeuss SWAXS instrument and subtract background data if necessary.
+"""
+import argparse as ap
+import matplotlib.ticker as ticker
+import matplotlib.pyplot as plt
+from matplotlib.colors import LogNorm
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+import pyFAI
+from pyFAI.integrator.azimuthal import AzimuthalIntegrator
+import fabio
+import numpy as np
+
+# pylint: disable=C0103, unused-variable
+def cli():
+    """Integrate 2D saxs data"""
+    parser = ap.ArgumentParser(
+        description="Perform data reduction on data from Xeuss 2.0C")
+
+    parser.add_argument("sample", help="sample file (.edf)")
+
+    parser.add_argument("mask", help="mask file (.edf)")
+    parser.add_argument("--poni", help="PONI configuration file (.poni)")
+    parser.add_argument("--empty", help="empty file (.edf)")
+    parser.add_argument("--background", help="background file (.edf)")
+    parser.add_argument(
+        "--opencl", help="Use OpenCL (requires pyopencl)", action="store_true")
+    parser.add_argument(
+        "--bkg_factor", help="background correction factor", type=float, default=float(1))
+    parser.add_argument(
+        "--lac", help="Convert to absolute units using the calculated thickness - LAC in cm^-1",type=float, default=float(0))
+    parser.add_argument(
+        "--thickness", help="thickness in cm used for transmission correction (otherwise, transmitted intensity used)",type=float, default=float(1))
+    parser.add_argument(
+        "--autobkg", help="Automatic background scaling", action="store_true")
+    args = parser.parse_args()
+
+
+    file = fabio.open(args.sample)
+    mask = fabio.open(args.mask)
+
+
+    if args.opencl:
+        intmeth = 'opencl'
+    else:
+        intmeth = 'csr'
+    if not args.poni:
+        geo = {
+            "detector": pyFAI.detectors.Detector(float(file.header['PSize_2']),float(file.header['PSize_1'])),
+            "dist": float(file.header['SampleDistance']),
+            "poni1": float(file.header['PSize_2'])*float(file.header['Center_2']),
+            "poni2": float(file.header['PSize_1'])*float(file.header['Center_1']),
+            "rot1": 0,
+            "rot2": 0,
+            "rot3": 0,
+            "wavelength": float(file.header['WaveLength'])
+        }
+
+        # poni = pyFAI.azimuthalIntegrator.AzimuthalIntegrator(**geo)
+
+        poni = AzimuthalIntegrator(**geo)
+    else:
+        poni = pyFAI.load(args.poni)
+
+    if np.allclose(args.lac, 0):
+        transmission_sample = args.thickness
+    else:
+        transmission_sample = -((1/args.lac)*np.log10(float(file.header['Transmission'])))
+
+    norm_sample = (float(file.header['Intensity1']) *
+                float(file.header['ExposureTime']) *
+                (
+                    (
+                        float(file.header['PSize_1']) /
+                        float(file.header['SampleDistance']))
+    )**2
+    )/1e-15
+
+
+    data_1D = poni.integrate1d(file.data,
+                            1000, filename=args.sample[:-4]+'_1D.dat', correctSolidAngle=True,
+                            method=intmeth, radial_range=(None), azimuth_range=(None),
+                            unit="q_A^-1", mask=mask.data, normalization_factor=norm_sample,
+                            metadata=None, error_model="poisson")
+
+    data_2D = file.data/transmission_sample
+
+    if args.background is not None:
+        bkg = fabio.open(args.background)
+        if np.allclose(args.lac, 0):
+            transmission_bkg = args.thickness
+        elif np.allclose(float(bkg.header['Transmission']), 1, atol=5e-3):
+            transmission_bkg = -((1/args.lac)*np.log10(1))
+        else:
+            transmission_bkg = -((1/args.lac)*np.log10(float(bkg.header['Transmission'])))
+        
+        norm_bkg = (float(bkg.header['Intensity1']) *
+                    float(bkg.header['ExposureTime']) *
+                    (
+                        (
+                            float(bkg.header['PSize_1']) /
+                            float(bkg.header['SampleDistance']))
+        )**2
+        )/1e-15
+        bkg_1D = poni.integrate1d(bkg.data,
+                                1000, filename=args.sample[:-4]+'_bkg1D.dat', correctSolidAngle=True,
+                                method=intmeth, radial_range=(None), azimuth_range=(None),
+                                unit="q_A^-1", mask=mask.data, normalization_factor=norm_bkg,
+                                metadata=None, error_model="poisson")
+
+        bkg_2D = bkg.data/transmission_bkg
+
+        if args.autobkg is True:
+            print("Use automated background scaling with caution!")
+            if max(bkg_1D[1][:np.where(bkg_1D[0] > 0.02)[0][0]]) > max(data_1D[1][:np.where(data_1D[0] > 0.02)[0][0]]):
+                bkg_1D = [bkg_1D[0], bkg_1D[1], bkg_1D[2]]
+                bkg_1D[1] -= max(bkg_1D[1][:np.where(bkg_1D[0] > 0.02)[0][0]]) - \
+                    max(data_1D[1][:np.where(data_1D[0] > 0.02)[0][0]])
+    else:
+        data_I = data_1D[1]
+        data_sig = abs(data_1D[2])
+    if args.empty is not None:
+        empty = fabio.open(args.empty)
+        if np.allclose(args.lac, 0):
+            transmission_empty = args.thickness
+        elif np.allclose(float(bkg.header['Transmission']), 1, atol=5e-3):
+            transmission_empty = -((1/args.lac)*np.log10(1))
+        else:
+            transmission_empty = -((1/args.lac)*np.log10(float(empty.header['Transmission'])))
+        norm_empty = (float(empty.header['Intensity1']) *
+                    float(empty.header['ExposureTime']) *
+                    (
+            (
+                float(empty.header['PSize_1']) /
+                float(empty.header['SampleDistance']))
+        )**2
+        )/1e-15
+        empty_1D = poni.integrate1d(empty.data,
+                                    1000, filename=args.sample[:-4]+'_empty1D.dat', correctSolidAngle=True,
+                                    method=intmeth, radial_range=(None), azimuth_range=(None),
+                                    unit="q_A^-1", mask=mask.data, normalization_factor=norm_empty,
+                                    metadata=None, error_model="poisson")
+
+        empty_2D = empty.data/transmission_empty
+        empty_1Df = empty_1D[1]
+
+        if args.autobkg is True:
+            if max(empty_1D[1][:np.where(empty_1D[0] > 0.02)[0][0]]) > max(data_1D[1][:np.where(data_1D[0] > 0.02)[0][0]]):
+                empty_1Df = empty_1D[1] - max(empty_1D[1][:np.where(empty_1D[0] > 0.02)[
+                                            0][0]]) - max(data_1D[1][:np.where(data_1D[0] > 0.02)[0][0]])
+
+        if args.background is not None:
+            data_I = ((data_1D[1]-empty_1Df) -
+                    (bkg_1D[1]-empty_1Df))*transmission_sample
+            data_2I = (data_2D-empty_2D)-(bkg_2D-empty_2D)
+            data_sig = (abs(data_1D[2])+abs(empty_1D[2]) +
+                        abs(bkg_1D[2])+abs(empty_1D[2]))*transmission_sample
+        else:
+            data_I = (data_1D[1]-empty_1Df)*transmission_sample
+            data_2I = data_2D-empty_2D
+            data_sig = (abs(data_1D[2])+abs(empty_1D[2]))*transmission_sample
+    else:
+        if args.background is None:
+            data_I = data_1D[1]*transmission_sample
+            data_2I = data_2D
+            data_sig = abs(data_1D[2])*transmission_sample
+        else:
+            data_I = (data_1D[1]-bkg_1D[1])*transmission_sample
+            data_2I = data_2D - bkg_2D
+            data_sig = (abs(data_1D[2])+abs(bkg_1D[2]))*transmission_sample
+
+    data_2I2 = poni.integrate2d(data_2I, 3000, 3600, unit="q_A^-1")
+
+    I2, q2, chi2 = data_2I2
+
+    if np.min(I2) < 0:
+        I2min = 1e-3
+    else:
+        I2min = np.min(I2)
+    I2max = np.max(I2)
+
+    fig, axs = plt.subplot_mosaic(
+        [['(a)', '(b)']], figsize=(7, 4), constrained_layout=True)
+
+    fig1 = axs['(a)'].imshow(I2, origin="lower", extent=[q2.min(), q2.max(), chi2.min(), chi2.max()],
+                            norm=LogNorm(vmin=I2min, vmax=I2max), cmap=plt.get_cmap('cividis'), aspect="auto")
+    divider = make_axes_locatable(axs['(a)'])
+    cax = divider.append_axes("top", size="5%", pad=0.05)
+
+    cbar = plt.colorbar(fig1, cax=cax, orientation="horizontal")
+    cbar.ax.tick_params(labelsize=8)
+    cax.xaxis.set_ticks_position("top")
+
+    axs['(a)'].set_xlabel(r'q /$\AA^{-1}$', fontsize=8)
+    axs['(a)'].set_ylabel(r'$\phi/^{\circ}$', fontsize=8)
+    axs['(a)'].tick_params(labelsize=8)
+
+    fig2 = axs['(b)'].errorbar(data_1D[0], data_I, yerr=data_sig, linestyle='')
+
+    axs['(b)'].set_xscale('log')
+    axs['(b)'].set_yscale('log')
+    axs['(b)'].set_xlabel(r'q /$\AA^{-1}$', fontsize=8)
+    if np.allclose(args.lac,0):
+        if np.allclose(args.thickness,1):
+            axs['(b)'].set_ylabel('I(q) /Arb.', fontsize=8)
+
+    else:
+        axs['(b)'].set_ylabel(r'I(q) /cm$^{-1}$.', fontsize=8)
+    axs['(b)'].get_xaxis().set_major_formatter(ticker.ScalarFormatter())
+    # axs['(b)'].get_yaxis().set_major_formatter(ticker.ScalarFormatter())
+    # axs['(b)'].ticklabel_format(style='sci', axis='both',
+    #                             scilimits=(0, 0), useMathText=True)
+    #axs['(b)'].set_xticks([0.01, 0.1, 1])
+    # axs['(b)'].get_xaxis().set_major_formatter(ticker.ScalarFormatter())
+    axs['(b)'].tick_params(labelsize=8)
+    # plt.show()
+    plt.savefig(args.sample[:-4]+".png", bbox_inches="tight",dpi=600)
+
+    data_out = np.column_stack((data_1D[0], data_I, data_sig))
+    np.savetxt(args.sample[:-4]+"_subtracted.dat",
+            data_out, delimiter='\t', fmt='%s')
+
+if __name__ == "__main__":
+    cli()

smswaxs/sph_harm.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+"""
+Plot spherical harmonics functions from TOPAS coefficients.
+
+This module visualizes spherical harmonics functions using coefficients
+obtained from TOPAS academic output files.
+"""
+
+import click
+import matplotlib.pyplot as plt
+from scipy.special import factorial
+from sympy.functions.special.polynomials import assoc_legendre
+import numpy as np
+from matplotlib import cm, colors
+
+# pylint: disable=C0103
+
+
+def Nlm(l, m):
+    """Calculate normalization factor for spherical harmonics."""
+    N = np.sqrt(((2*l+1)/(4*np.pi))*(factorial((l-m))/factorial((l+m))))
+    return N
+
+
+def spherical_harmonic(l, m, theta, phi=None):
+    """
+    Calculate real spherical harmonic Y_lm.
+    
+    Args:
+        l: degree of the harmonic
+        m: order of the harmonic (0 for m=0, positive for cos, negative for sin)
+        theta: polar angle(s)
+        phi: azimuthal angle(s), required if m != 0
+    
+    Returns:
+        Real spherical harmonic values
+    """
+    if m == 0:
+        return Nlm(l, 0) * assoc_legendre(l, 0, np.cos(theta))
+    else:
+        abs_m = abs(m)
+        legendre_part = assoc_legendre(l, abs_m, np.cos(theta))
+        norm = np.sqrt(2) * Nlm(l, abs_m)
+        if m > 0:  # cosine term (p for plus)
+            return norm * np.cos(abs_m * phi) * legendre_part
+        else:  # sine term (m for minus)
+            return norm * np.sin(abs_m * phi) * legendre_part
+
+
+# Define the coefficient structure: (l, m) pairs
+# m=0 for Y_l0, m>0 for cos terms (p), m<0 for sin terms (m)
+COEFFICIENT_STRUCTURE = [
+    (0, 0),   # c00
+    (2, 0),   # c20
+    (2, 2),   # c22p
+    (2, -2),  # c22m
+    (4, 0),   # c40
+    (4, 2),   # c42p
+    (4, -2),  # c42m
+    (4, 4),   # c44p
+    (4, -4),  # c44m
+    (6, 0),   # c60
+    (6, 2),   # c62p
+    (6, -2),  # c62m
+    (6, 4),   # c64p
+    (6, -4),  # c64m
+    (6, 6),   # c66p
+    (6, -6),  # c66m
+    (8, 0),   # c80
+    (8, 2),   # c82p
+    (8, -2),  # c82m
+    (8, 4),   # c84p
+    (8, -4),  # c84m
+    (8, 6),   # c86p
+    (8, -6),  # c86m
+    (8, 8),   # c88p
+    (8, -8),  # c88m
+]
+
+@click.command()
+@click.argument('coefficients', nargs=-1, type=float, required=True)
+@click.option('--output', '-o', default='sph_harm.svg',
+              help='Output filename for the plot (default: sph_harm.svg)')
+@click.option('--resolution', '-r', default=200,
+              help='Angular resolution for the plot (default: 200)')
+def cli(coefficients, output, resolution):
+    """
+    Plot spherical harmonics functions from TOPAS coefficients.
+    
+    Takes 1 to 25 coefficients and generates a 3D visualization of the spherical
+    harmonics function. Coefficients should be provided in order:
+    c00, c20, c22p, c22m, c40, c42p, c42m, c44p, c44m, c60, c62p, c62m, c64p, c64m,
+    c66p, c66m, c80, c82p, c82m, c84p, c84m, c86p, c86m, c88p, c88m
+    
+    If fewer than 25 coefficients are provided, the remaining ones are assumed to be zero.
+    This allows for 2nd order (5 coeffs), 4th order (9 coeffs), 6th order (16 coeffs), etc.
+    
+    Use '--' before coefficients if any are negative to prevent them being interpreted as options.
+    
+    Examples:
+        # 2nd order (5 coefficients)
+        sm-spharm -- 1 -0.54889 0.48504 0.74711 0.79916
+        
+        # 8th order (25 coefficients)
+        sm-spharm -- 1 -0.54889 0.48504 0.74711 0.79916 -0.33178 0.16323 0.45369 \
+                     -0.29782 -0.29214 -0.43949 0.01524 0.09042 0.85340 0.40316 \
+                     -0.01881 1.47673 -0.55751 -0.68970 0.02621 -0.06565 -0.56472 \
+                     1.00981 -0.12339 -0.25831
+    """
+    # Validate number of coefficients
+    if len(coefficients) > 25:
+        raise click.BadParameter(
+            f'Too many coefficients: got {len(coefficients)}, maximum is 25'
+        )
+    
+    # Pad coefficients with zeros if fewer than 25 provided
+    coefficients = list(coefficients) + [0.0] * (25 - len(coefficients))
+    
+    # Create angular grid
+    phi, theta = np.mgrid[0:2*np.pi:complex(0, resolution), 0:np.pi:complex(0, resolution//2)]
+    
+    # Calculate radial function R by summing all harmonics
+    R = np.zeros_like(theta, dtype=float)
+    
+    for (l_val, m_val), coeff in zip(COEFFICIENT_STRUCTURE, coefficients):
+        if m_val == 0:
+            # For m=0, only theta is needed
+            y_lm_func = np.frompyfunc(lambda t, lv=l_val, mv=m_val: spherical_harmonic(lv, mv, t), 1, 1)
+            y_values = y_lm_func(theta).astype(float)
+        else:
+            # For m!=0, both theta and phi are needed
+            y_lm_func = np.frompyfunc(lambda t, p, lv=l_val, mv=m_val: spherical_harmonic(lv, mv, t, p), 2, 1)
+            y_values = y_lm_func(theta, phi).astype(float)
+        
+        R += coeff * y_values
+
+    # Convert to Cartesian coordinates
+    x = R*np.sin(theta)*np.cos(phi)
+    y = R*np.sin(theta)*np.sin(phi)
+    z = R*np.cos(theta)
+
+    # Create 3D plot
+    # pylint: disable=E1101
+    _, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14, 10))
+    norm = colors.Normalize()
+    ax.plot_surface(x, y, z, rstride=1, cstride=1, facecolors=cm.jet(norm(R)))
+    
+    ax.set_xlabel('X')
+    ax.set_ylabel('Y')
+    ax.set_zlabel('Z')
+    ax.set_title('Spherical Harmonics Visualization')
+
+    # Save the plot
+    plt.savefig(output, bbox_inches='tight')
+    click.echo(f'Plot saved to {output}')
+
+
+if __name__ == "__main__":
+    # pylint: disable=E1120
+    cli()

smswaxs/topas_init.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Dec 20 11:38:05 2023
+
+@author: u0092172
+"""
+
+import sys
+def cli():
+    if len(sys.argv) != 2:
+        print("Usage: python topas_init.py <input_file>")
+        sys.exit(1)
+    with open(sys.argv[1],'r',encoding="utf-8") as inputfile:
+        data = inputfile.readlines()
+
+    for i, line in enumerate(data):
+        if 'xdd' in line:
+            data[i] = 'xdd '+sys.argv[1][:-3]+'xye\n'
+
+    with open(sys.argv[1], 'w',encoding="utf-8") as outfile:
+        outfile.writelines(data)
+
+if __name__ == "__main__":
+    cli()

smswaxs/waxs_integration_xeuss.py

@@ -0,0 +1,239 @@
+"""
+This script will integrate 2D SAXS data collected on the Xenocs
+Xeuss SWAXS instrument and subtract background data if necessary.
+"""
+import argparse as ap
+import matplotlib.ticker as ticker
+import matplotlib.pyplot as plt
+from matplotlib.colors import LogNorm
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+import pyFAI
+from pyFAI.integrator.azimuthal import AzimuthalIntegrator
+import fabio
+import numpy as np
+
+# pylint: disable=C0103, unused-variable
+
+
+def cli():
+    """Integrate 2D saxs data"""
+    parser = ap.ArgumentParser(
+        description="Perform data reduction on data from Xeuss 2.0C")
+
+    parser.add_argument("sample", help="sample file (.edf)")
+
+    parser.add_argument("mask", help="mask file (.edf)")
+    parser.add_argument("--poni", help="PONI configuration file (.poni)")
+    parser.add_argument("--background", help="background file (.edf)")
+    parser.add_argument(
+        "--opencl", help="Use OpenCL (requires pyopencl)", action="store_true")
+    parser.add_argument(
+        "--bkg_factor", help="background correction factor", type=float, default=float(1))
+    parser.add_argument(
+        "--lac", help="Convert to absolute units using the calculated thickness - LAC in cm^-1",
+        type=float, default=float(0))
+    parser.add_argument(
+        "--thickness", help="thickness /cm used for trans. cor. (otherwise, trans. int. used)",
+        type=float, default=float(0))
+    parser.add_argument(
+        "--xmin", help="Minimum value of radial unit (q)", type=float)
+    parser.add_argument(
+        "--xmax", help="Max value of radial unit (q)", type=float, default=3.8)
+    parser.add_argument(
+        "--raw2D", help="Display the 2D image in the lab frame", action="store_true")
+    parser.add_argument(
+        "--noabs", help="No absorption correction", action="store_true")
+    parser.add_argument(
+        "--unit", help="Radial unit for integration, q or 2th", type=str, default="q")
+    args = parser.parse_args()
+
+    if args.unit.lower() == "q":
+        UNIT = "q_A^-1"
+
+    elif args.unit.lower() == "2th":
+        UNIT = "2th_deg"
+    else:
+        raise ValueError("Unit must be 'q' or '2th'")
+    if args.xmin:
+        radran = (args.xmin, args.xmax)
+    else:
+        radran = (None)
+    file = fabio.open(args.sample)
+    mask = fabio.open(args.mask)
+    if args.noabs is False:
+        def abscor(tth, intensity, trans):
+            """Absorption correction for WAXS according to the Bragg corrections section of the
+            XSACT user manual (2020)"""
+            if np.allclose(trans, 1, atol=5e-3):
+                return intensity
+            else:
+                fabs = (np.log(trans)*((1/np.cos(np.radians(tth)))-1)) / \
+                    (np.exp(np.log(trans)*((1/np.cos(np.radians(tth)))-1))-1)
+                cor_int = intensity/fabs
+                return cor_int
+    else:
+        def abscor(_, intensity, __):
+            return intensity
+
+    if args.opencl:
+        intmeth = 'opencl'
+    else:
+        intmeth = 'csr'
+    if not args.poni:
+        geo = {
+            "detector": pyFAI.detectors.Detector(float(file.header['PSize_2']), 
+                                                 float(file.header['PSize_1'])),
+            "dist": float(file.header['SampleDistance']),
+            "poni1": float(file.header['PSize_2'])*float(file.header['Center_2']),
+            "poni2": float(file.header['PSize_1'])*float(file.header['Center_1']),
+            "rot1": 0,
+            "rot2": 0,
+            "rot3": 0,
+            "wavelength": float(file.header['WaveLength'])
+        }
+
+        # poni = pyFAI.azimuthalIntegrator.AzimuthalIntegrator(**geo)
+
+        poni = AzimuthalIntegrator(**geo)
+    else:
+        poni = pyFAI.load(args.poni)
+    try:
+        transmission_sample = float(file.header['Transmission'])
+    except KeyError:
+        if np.allclose(args.lac, 0):
+            args.noabs = True
+            transmission_sample = 1
+        else:
+            if np.allclose(args.thickness, 0) is False:
+                transmission_sample = np.exp(-args.lac*args.thickness)
+            else:
+                args.noabs = True
+                transmission_sample = 1
+    norm_sample = (float(file.header['Intensity1']) *
+                   float(file.header['ExposureTime']) *
+                   (
+        (
+            float(file.header['PSize_1']) /
+            float(file.header['SampleDistance']))
+    )**2
+    )/1e-15
+
+    data_1D = poni.integrate1d(file.data,
+                               1000, filename=args.sample[:-4]+'_1D.dat', correctSolidAngle=True,
+                               method=intmeth, radial_range=radran, azimuth_range=(None),
+                               unit=UNIT, mask=mask.data, normalization_factor=norm_sample,
+                               metadata=None, error_model="poisson")
+
+    data_1D_corr = [data_1D[0], data_1D[1], data_1D[2]]
+    if args.unit.lower() == "2th":
+        data_1D_corr[1] = abscor(data_1D[0], data_1D[1], transmission_sample)
+    else:
+        data_1D_corr[1] = abscor(2*np.degrees(np.arcsin(((float(file.header['WaveLength'])/1e-10)
+                                 * data_1D[0])/(4*np.pi))), data_1D[1], transmission_sample)
+    data_2D = file.data/transmission_sample
+
+    if args.background is not None:
+        bkg = fabio.open(args.background)
+        if np.allclose(float(bkg.header['Transmission']), 1, atol=5e-3):
+            transmission_bkg = 1
+        else:
+            transmission_bkg = float(bkg.header['Transmission'])
+
+        norm_bkg = (float(bkg.header['Intensity1']) *
+                    float(bkg.header['ExposureTime']) *
+                    (
+                        (
+                            float(bkg.header['PSize_1']) /
+                            float(bkg.header['SampleDistance']))
+        )**2
+        )/1e-15
+        bkg_1D = poni.integrate1d(bkg.data,
+                                  1000, filename=args.sample[:-4]+'_bkg1D.dat',
+                                  correctSolidAngle=True, method=intmeth,
+                                  radial_range=radran, azimuth_range=(None),
+                                  unit=UNIT, mask=mask.data, normalization_factor=norm_bkg,
+                                  metadata=None, error_model="poisson")
+
+        bkg_1D_corr = [bkg_1D[0], bkg_1D[1], bkg_1D[2]]
+        if args.unit.lower() == "2th":
+            bkg_1D_corr[1] = abscor(bkg_1D[0], bkg_1D[1], transmission_bkg)
+        else:
+            bkg_1D_corr[1] = abscor(
+                2*np.degrees(np.arcsin(((float(file.header['WaveLength'])/1e-10)*bkg_1D[0])/
+                                       (4*np.pi))), bkg_1D[1], transmission_bkg)
+        bkg_2D = bkg.data/transmission_bkg * args.bkg_factor
+        data_I = data_1D_corr[1]-bkg_1D_corr[1]
+        data_2I = data_2D - bkg_2D
+        data_sig = abs(data_1D_corr[2])+abs(bkg_1D_corr[2])
+    else:
+        data_I = data_1D_corr[1]
+        data_2I = data_2D
+        data_sig = data_1D_corr[2]
+
+    data_2I2 = poni.integrate2d(data_2I, 3000, 3600, unit=UNIT)
+
+    I2, q2, chi2 = data_2I2
+
+    if np.min(I2) < 0:
+        I2min = 1e-3
+    else:
+        I2min = np.min(I2)
+    I2max = np.max(I2)
+
+    fig, axs = plt.subplot_mosaic(
+        [['(a)', '(b)']], figsize=(7, 4), constrained_layout=True)
+    if args.raw2D is False:
+        fig1 = axs['(a)'].imshow(I2, origin="lower",
+                                 extent=[q2.min(), q2.max(), chi2.min(), chi2.max()],
+                                 norm=LogNorm(vmin=I2min, vmax=I2max), cmap=plt.get_cmap('cividis'),
+                                 aspect="auto")
+        if args.unit.lower() == "q":
+            axs['(a)'].set_xlabel(r'q /$\AA^{-1}$', fontsize=8)
+        else:
+            axs['(a)'].set_xlabel(r'2$\theta$ /$^{\circ}$', fontsize=8)
+        axs['(a)'].set_ylabel(r'$\phi/^{\circ}$', fontsize=8)
+    else:
+        fig1 = axs['(a)'].imshow(data_2I, norm=LogNorm(
+            vmin=I2min, vmax=I2max), cmap=plt.get_cmap('cividis'), aspect="auto")
+        axs['(a)'].set_xlabel('X /px', fontsize=8)
+        axs['(a)'].set_ylabel('Z /px', fontsize=8)
+    divider = make_axes_locatable(axs['(a)'])
+    cax = divider.append_axes("top", size="5%", pad=0.05)
+
+    cbar = plt.colorbar(fig1, cax=cax, orientation="horizontal")
+    cbar.ax.tick_params(labelsize=8)
+    cax.xaxis.set_ticks_position("top")
+
+    axs['(a)'].tick_params(labelsize=8)
+
+    fig2 = axs['(b)'].plot(data_1D[0], data_I, linewidth=0.5)
+
+    # axs['(b)'].set_xscale('log')
+    # axs['(b)'].set_yscale('log')
+    if args.unit.lower() == "q":
+        axs['(b)'].set_xlabel(r'q /$\AA^{-1}$', fontsize=8)
+    else:
+        axs['(b)'].set_xlabel(r'2$\theta$ /$^{\circ}$', fontsize=8)
+    axs['(b)'].set_ylabel('I(q) /Arb.', fontsize=8)
+    axs['(b)'].get_xaxis().set_major_formatter(ticker.ScalarFormatter())
+    # axs['(b)'].get_yaxis().set_major_formatter(ticker.ScalarFormatter())
+    # axs['(b)'].ticklabel_format(style='sci', axis='both',
+    #                             scilimits=(0, 0), useMathText=True)
+    # axs['(b)'].set_xticks([0.01, 0.1, 1])
+    # axs['(b)'].get_xaxis().set_major_formatter(ticker.ScalarFormatter())
+    axs['(b)'].tick_params(labelsize=8)
+    # plt.show()
+    plt.savefig(args.sample[:-4]+".png", bbox_inches="tight",dpi=600)
+
+    data_out = np.column_stack((data_1D[0], data_I, data_sig))
+    if args.unit.lower() == "q":
+        header_str = "q(A^-1)\tI(Arb.)\tSigma(Arb.)"
+        np.savetxt(args.sample[:-4]+"_subtracted.dat",
+                   data_out, delimiter='\t', fmt='%s', header=header_str)
+    elif args.unit.lower() == "2th":
+        np.savetxt(args.sample[:-4]+".xye",
+                   data_out, delimiter='\t', fmt='%s')
+
+
+if __name__ == "__main__":
+    cli()

smswaxs/xeuss_dat_h5_multi.py

@@ -0,0 +1,48 @@
+"""This script converts XSACT or Foxtrot dat files to HDF5 format for archival storage"""
+import sys
+import re
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+import h5py
+import numpy as np
+
+def get_line_number(phrase: str, file_name: str):
+    """Determine the line in the text file containing the specified str"""
+    with open(file_name, encoding="utf-8") as f:
+        for i, line in enumerate(f, 1):
+            p = re.compile(phrase)
+            if p.match(line) is not None:
+                return i
+
+def process_dat_file(file_path: str, hdf):
+    """determine the header and data block in the dat file and create an
+    hdf5 dataset"""
+    dataset_name = file_path.stem
+    with open(file_path, encoding="utf-8") as infile:
+        lines = infile.read().splitlines()
+        lines = [line.replace('##', ' ') for line in lines]
+        meta = {s.split("   ")[0].replace("# ", "").strip(): s.split(
+            "   ")[-1].strip() for s in lines if '#' in s}
+        meta = {key.replace("#",""): value.replace("#","") for key,value in meta.items()}
+        meta = {key: value for key, value in meta.items() if key}
+        head = get_line_number('.*q\\([AÅ].*',file_path)
+        meta["columns"] = lines[head-1].split()
+        data = np.genfromtxt(file_path,skip_header=head,usecols=(0,1,2),encoding="utf-8")
+
+    dset = hdf.create_dataset(
+        dataset_name, data=data, compression='gzip')
+
+    for attr_name, attr_value in meta.items():
+        dset.attrs[attr_name] = attr_value
+
+def add_dats_to_hdf5(directory: str, hdf5_filename: str):
+    """find all dat files in the current folder and subfolders, then 
+    add them to a single hdf5 file"""
+    files = list(Path(directory).glob('**/*.dat'))
+    hdf = h5py.File(hdf5_filename,'w')
+    with ThreadPoolExecutor() as executor:
+        executor.map(lambda file: process_dat_file(file, hdf), files)
+    hdf.close()
+
+if __name__ == '__main__':
+    add_dats_to_hdf5(sys.argv[1],sys.argv[2])

smswaxs/xeuss_edf_h5_multi.py

@@ -0,0 +1,39 @@
+"""This script converts Xeuss edf files to HDF5 format for archival storage"""
+import argparse as ap
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+import fabio
+import h5py
+
+
+
+def process_edf_file(file_path: Path, hdf):
+    """Create hdf5 dataset from edf file"""
+    infile = fabio.open(file_path)
+    dataset_name = file_path.stem
+    
+    dset = hdf.create_dataset(
+        dataset_name, data=infile.data, compression='gzip')
+    
+    for attr_name, attr_value in infile.header.items():
+        dset.attrs[attr_name] = attr_value
+
+def add_edfs_to_hdf5():
+    """Find all edf files in all subdirectories of the specified
+    path and add them to the hdf5"""
+    parser = ap.ArgumentParser(description="Convert Xeuss edf files to HDF5 format")
+    parser.add_argument("directory", help="Directory containing edf files")
+    args = parser.parse_args()
+    if ".edf" in args.directory:
+        files = [Path(args.directory)]
+        args.hdf5_filename = files[0].with_suffix('.h5').name
+    else:
+        files = list(Path(args.directory).glob('**/*.edf'))
+        args.hdf5_filename = Path(args.directory).name + '.h5'
+    hdf = h5py.File(args.hdf5_filename,'w')
+    with ThreadPoolExecutor() as executor:
+        executor.map(lambda file: process_edf_file(file, hdf), files)
+    hdf.close()
+
+if __name__ == '__main__':
+    add_edfs_to_hdf5()

smswaxs/xeuss_edf_tiff.py

@@ -0,0 +1,26 @@
+"""This script converts Xeuss edf files to TIFF format + JSON for archival storage"""
+import sys
+from pathlib import Path
+import json
+import fabio
+from PIL import Image
+
+file_path = Path(sys.argv[1])
+
+infile = fabio.open(file_path)
+
+output_path = file_path.with_suffix(".tif")
+json_output = file_path.with_suffix(".json")
+
+"""The original edf files contain 32-bit floats, so the F mode is used to
+retain precision, however, mask files are only 8-bit and will throw an error,
+in this case we fall back to auto detection"""
+try:
+    image = Image.fromarray(infile.data,mode='F')
+except ValueError:
+    image = Image.fromarray(infile.data)
+
+image.save(output_path,format='TIFF',compression='tiff_deflate')
+
+with open(json_output, 'w',encoding="utf-8") as json_f:
+    json.dump(infile.header, json_f, indent=4)

smswaxs/xrdml_conv.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""
+Convert xrdml files to xy format for use in TOPAS. Extract metadata, but drop units from pint quantities.
+@author: u0092172
+"""
+from pathlib import Path
+import json
+import argparse as ap
+import numpy as np
+from fairmat_readers_xrd import read_file
+
+
+def _to_magnitude(obj):
+    """Recursively convert pint quantities to their magnitudes."""
+    if hasattr(obj, 'magnitude'):
+        return obj.magnitude
+    if isinstance(obj, dict):
+        return {k: _to_magnitude(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        converted = [_to_magnitude(v) for v in obj]
+        return tuple(converted) if isinstance(obj, tuple) else converted
+    return obj
+
+def cli():
+    """Convert xrdml files to xy format for use in TOPAS"""
+    parser = ap.ArgumentParser(description='Sort out xrdml files')
+    parser.add_argument("input", help="xrdml file")
+    args = parser.parse_args()  # map arguments to args
+
+
+
+    data = read_file(args.input)
+    two_theta = data['2Theta'].magnitude
+    intensity = data['intensity'].magnitude
+
+    metadata = _to_magnitude(data['metadata'])
+
+    outfile = Path(args.input).with_suffix('.xy')
+
+    np.savetxt(outfile, np.column_stack((two_theta, intensity)), fmt='%1.6f', delimiter='\t')
+
+    meta_outfile = Path(args.input).with_suffix('.json')
+    with open(meta_outfile, 'w') as f:
+        json.dump(metadata, f, indent=4)
+
+
+if __name__ == '__main__':
+    cli()

susmat_swaxs-2.1.3.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.3
+Name: SusMat-SWAXS
+Version: 2.1.3
+Summary: A collection of python scripts for uploading analytical data to iRODS
+Author: Samuel Eyley
+Author-email: Samuel Eyley <susmat-swaxspypi.xepsj@simplelogin.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: pyfai>2024.10.0
+Requires-Dist: pyopencl
+Requires-Dist: click
+Requires-Dist: pyside6
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: sympy
+Requires-Dist: fabio
+Requires-Dist: hdf5plugin
+Requires-Dist: pillow
+Requires-Dist: fairmat-readers-xrd>=0.0.8
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/Sustainable-Materials-Lab/SusMat-SWAXS
+Project-URL: Issues, https://github.com/Sustainable-Materials-Lab/SusMat-SWAXS/issues
+Description-Content-Type: text/markdown
+
+# SWAXS tools
+
+## Description
+This is a collection of scripts to perform data conversion and integration on X-ray scattering data, specifically for data collected on the Xenocs Xeuss SWAXS instrument.
+
+**Available tools:**
+- `sm-datconv` - Converts Xenocs format 1D data (.dat) to TOPAS compatible .xye format
+- `sm-edfh5` - Convert EDF files to HDF5 format with metadata preservation
+- `sm-saxsint` - Integrate 2D SAXS data from Xenocs Xeuss instruments with background subtraction
+- `sm-waxsint` - Integrate 2D WAXS data from Xenocs Xeuss instruments with absorption correction
+- `sm-spharm` - Visualize spherical harmonics functions from TOPAS coefficients
+
+## Installation
+Install in a virtual environment to avoid dependency conflicts:
+
+```bash
+pip install SusMat-SWAXS
+```
+
+
+## Usage
+All scripts are available as command-line tools after installation. Use the `--help` flag with any command to see detailed usage information.
+
+### sm-datconv
+Converts Xenocs format 1D data (.dat) to TOPAS compatible .xye format.
+
+**Input:** `.dat` file with tab-separated columns for q, I(q) (and optionally sigma).
+
+**Usage:**
+```bash
+sm-datconv <filename_without_extension>
+```
+
+**Output:** `.xye` file with tab-separated columns for 2θ, I, and error (if present in input).
+
+**Batch processing example (PowerShell):**
+```powershell
+Get-ChildItem -Filter *.dat | ForEach-Object -Process {sm-datconv $_.BaseName}
+```
+
+### sm-xrdmlconv
+Converts Malvern PANalytical format 1D data (.xrdml) to TOPAS compatible .xy format.
+
+**Input:** `.xrdml` file .
+
+**Usage:**
+```bash
+sm-xrdmlconv <filename_without_extension>
+```
+
+**Output:** `.xy` file with tab-separated columns for 2θ and I and a `.json` file containing metadata.
+
+### sm-edfh5
+Convert multiple EDF files to a single HDF5 file with metadata preservation.
+
+**Usage:**
+```bash
+sm-edfh5 <path to directory containing edf files>
+```
+
+### sm-saxsint
+Integrate 2D SAXS data from Xenocs Xeuss instruments with background subtraction and absorption correction.
+
+**Usage:**
+```bash
+sm-saxsint <sample.edf> <mask.edf> [OPTIONS]
+```
+
+**Key options:**
+- `--poni <file.poni>` - PONI calibration file
+- `--background <bkg.edf>` - Background file for subtraction
+- `--bkg_factor <float>` - Background scaling factor (default: 1.0)
+- `--unit <q|2th>` - Radial unit for integration (default: q)
+- `--xmin <float>` - Minimum q value (default: 0.004)
+- `--xmax <float>` - Maximum q value (default: 0.7)
+- `--opencl` - Use OpenCL acceleration (requires pyopencl)
+- `--raw2D` - Display 2D image in lab frame
+
+**Output:** 
+- `*_1D.dat` - Integrated 1D data
+- `*_subtracted.dat` - Background-subtracted data
+- `*.svg` - Visualization plot
+
+### sm-waxsint
+Integrate 2D WAXS data from Xenocs Xeuss instruments with absorption correction.
+
+**Usage:**
+```bash
+sm-waxsint <sample.edf> <mask.edf> [OPTIONS]
+```
+
+**Key options:**
+- `--poni <file.poni>` - PONI calibration file
+- `--background <bkg.edf>` - Background file for subtraction
+- `--bkg_factor <float>` - Background scaling factor (default: 1.0)
+- `--unit <q|2th>` - Radial unit for integration (default: q)
+- `--xmin <float>` - Minimum q value (default: 0.36)
+- `--xmax <float>` - Maximum q value (default: 3.8)
+- `--lac <float>` - Linear absorption coefficient in cm⁻¹ for thickness correction
+- `--thickness <float>` - Sample thickness in cm for transmission correction
+- `--noabs` - Disable absorption correction
+- `--opencl` - Use OpenCL acceleration (requires pyopencl)
+- `--raw2D` - Display 2D image in lab frame
+
+**Output:**
+- `*_1D.dat` - Integrated 1D data
+- `*_subtracted.dat` - Background-subtracted, absorption-corrected data
+- `*.svg` - Visualization plot
+
+### sm-spharm
+Visualize spherical harmonics functions using coefficients from TOPAS academic output files.
+
+**Usage:**
+```bash
+sm-spharm C00 C20 C22P C22M C40 C42P C42M C44P C44M C60 C62P C62M C64P C64M C66P C66M C80 C82P C82M C84P C84M C86P C86M C88P C88M [OPTIONS]
+```
+
+**Arguments:** 25 spherical harmonics coefficients (c00 through c88m) from TOPAS output file
+
+**Options:**
+- `--output <filename>` / `-o <filename>` - Output filename for the plot (default: sph_harm.svg)
+- `--resolution <int>` / `-r <int>` - Angular resolution for the plot (default: 200)
+
+**Example:**
+```bash
+sm-spharm 1 -0.54889 0.48504 0.74711 0.79916 -0.33178 0.16323 0.45369 \
+          -0.29782 -0.29214 -0.43949 0.01524 0.09042 0.85340 0.40316 \
+          -0.01881 1.47673 -0.55751 -0.68970 0.02621 -0.06565 -0.56472 \
+          1.00981 -0.12339 -0.25831 --output my_spherical_harmonics.svg
+```
+
+**Output:** 3D visualization plot showing the spherical harmonics function in real space
+
+## Support
+Submit an issue on github: https://github.com/Sustainable-Materials-Lab/SusMat-SWAXS
+
+## Contributing
+Contact Samuel Eyley if you are interested in contributing.
+
+## Authors and acknowledgment
+Originally authored by Samuel Eyley. 
+
+Significant portions of code were developed with the help of Github Copilot (2025).
+
+## License
+MIT License

susmat_swaxs-2.1.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+smswaxs/__init__.py,sha256=kXT2_MXyf8y-GSFimdeq6rMi8To60hKqiSIyhrS0-Pk,962
+smswaxs/dat_conv.py,sha256=MuHSmV9Yd9pJVAkkLOo7sVzlmgwXneAjYauhxnuurMo,4373
+smswaxs/saxs_integration.py,sha256=qNNPoK26n0qS0ZsmMzhLINkpR9BzDkksc2VGfWeE4MI,6472
+smswaxs/saxs_integration_xeuss.py,sha256=WJu4IvkqY1LfcGokT-KIP0wNxKvRN47AmOy34vo-0OI,9764
+smswaxs/sph_harm.py,sha256=PKpSpLVXYoCjLWPb6bzzXPTpnheQ3LCL6jHd6KDuVeA,5554
+smswaxs/topas_init.py,sha256=5zRSGK0Qz8cqFdcL9EJQ9Oe-q7BjBe_EByCW2TikQbI,563
+smswaxs/waxs_integration_xeuss.py,sha256=a9-3vNAFH8dAHc0PyFD-oT4ksdjYABsfJoJvuhFj6ps,9925
+smswaxs/xeuss_dat_h5_multi.py,sha256=U2BY8fh0tEXmIWewfthzqltT1aEIeluoJGXg6b7lTr0,1979
+smswaxs/xeuss_edf_h5_multi.py,sha256=kiG8qG7LSlHm7d6sCCgC-lkSRwSykUa-BIYsSplp31Q,1370
+smswaxs/xeuss_edf_tiff.py,sha256=25XxAk9o8C3zV--pu8EyMtfQXbqdRymYUcdKFL3fsHE,807
+smswaxs/xrdml_conv.py,sha256=yM0h037OqX2AxMdim6UUUAD3AUCc7M7hL-yRaglYmuA,1441
+susmat_swaxs-2.1.3.dist-info/WHEEL,sha256=M4DeIjVCA49okfALADZoWX5JOGwnmHb-JOpQHtI-1c0,80
+susmat_swaxs-2.1.3.dist-info/entry_points.txt,sha256=Jbp7q-UnvB425gUtK4fx7uUDUg2M1zhs-RrDLzVi5kw,313
+susmat_swaxs-2.1.3.dist-info/METADATA,sha256=wovQaqxLi5iqSX6aOCZj-0Lhx-zHpYTkh17zx-DQijo,5888
+susmat_swaxs-2.1.3.dist-info/RECORD,,

susmat_swaxs-2.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.2
+Root-Is-Purelib: true
+Tag: py3-none-any

susmat_swaxs-2.1.3.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+sm-datconv = smswaxs.dat_conv:cli
+sm-edfh5 = smswaxs.xeuss_edf_h5_multi:add_edfs_to_hdf5
+sm-saxsint = smswaxs.saxs_integration_xeuss:cli
+sm-spharm = smswaxs.sph_harm:cli
+sm-topasinit = smswaxs.topas_init:cli
+sm-waxsint = smswaxs.waxs_integration_xeuss:cli
+sm-xrdmlconv = smswaxs.xrdml_conv:cli
+