ScatTools 0.0.1__py3-none-any.whl

gid/__init__.py

@@ -0,0 +1,2 @@
+from .gid import calculate_cell_parameters as calculate_cell_parameters
+from .gid import calculate_q_values as calculate_q_values

gid/gid.py

@@ -0,0 +1,154 @@
+import logging
+import math
+
+import numpy as np
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger(__name__)
+
+
+def calculate_cell_parameters(qxy1, qxy2, qxy3, qz1, qz2, qz3):
+    """
+    Calculates crystallographic parameters based on scattering vectors.
+    Args:
+        qxy1 (float): q_{xy} position of the first peak
+        qxy2 (float): q_{xy} position of the second peak
+        qxy3 (float): q_{xy} position of the third peak
+        qz1 (float): q_{z} position of the first peak
+        qz2 (float): q_{z} position of the second peak
+        qz3 (float): q_{z} position of the third peak
+    Returns:
+
+    """
+
+    vectors = sorted([
+        (qxy1, qz1),
+        (qxy2, qz2),
+        (qxy3, qz3)
+    ], key=lambda v: v[0])
+
+    qx10, qz10 = vectors[0]
+    qx01, qz01 = vectors[1]
+    qx11, qz11 = vectors[2]
+
+    cos_g = (qx10 ** 2 + qx01 ** 2 - qx11 ** 2) / (2 * qx10 * qx01)
+    if abs(cos_g) > 1.0:
+        logger.warning('Error: Check input values (cos G > 1).')
+        return None
+
+    gam_rad = np.acos(cos_g)  # Angle between A and B in real space
+
+    a = 2 * np.pi / (qx10 * np.sin(gam_rad))
+    b = 2 * np.pi / (qx01 * np.sin(gam_rad))
+
+
+    if abs(qz10 + qz01 - qz11) > 0.03:
+        qz10 = -qz10
+
+    if abs(qz10 + qz01 - qz11) > 0.03:
+        qz11 = -qz11
+
+    # Normal components
+    nz = qx10 * qx01 * np.sin(gam_rad)
+    nx = -qz10 * qx01 * np.sin(gam_rad)
+    ny = -(qx10 * qz01 + qz10 * qx01 * np.cos(gam_rad))
+    nmod = np.sqrt(nx ** 2 + ny ** 2 + nz ** 2)
+
+    if nmod == 0 or abs(nz / nmod) > 1.0:
+        logger.warning('Error: Check input values (Nz/Nmod > 1).')
+        return None
+
+    t3_rad = math.acos(nz / nmod)
+
+    # Azimuth: Angle between projection of N on XOY where OX==a* and OY==b*
+    if t3_rad == 0.0:
+        azimuth3_rad = 0.0
+    else:
+        if nx == 0.0:
+            azimuth3_rad = 0.0
+        else:
+            azimuth3_rad = np.atan(ny / nx)
+
+    area = a * b * np.sin(gam_rad)
+
+    # Convert angles to degrees
+    gam_deg = np.rad2deg(gam_rad)
+    if gam_deg > 180.0:
+        gam_deg = 360.0 - gam_deg
+
+    t3_deg = np.rad2deg(t3_rad)
+
+    # Azimuth = counter-clockwise rotation from real space A-vector
+    if azimuth3_rad != 0.0:
+        azimuth3_deg = np.rad2deg(azimuth3_rad) + (gam_deg - 90.0)
+    else:
+        azimuth3_deg = 0.0
+
+    return {
+        "a": np.round(a, 5),
+        "b": np.round(b, 5),
+        "gamma": np.round(gam_deg,2),
+        "tilt": np.round(t3_deg,2),
+        "azimuth": np.round(azimuth3_deg,2),
+        "area": np.round(area, 3)
+    }
+
+def calculate_q_values(a, b, gamma, tilt, azimuth):
+    """
+    Calculates the scattering vectors (qxy, qz) based on 2D crystallographic parameters.
+    Args:
+        a (float): Unit cell parameter a
+        b (float): Unit cell parameter b
+        gamma (float): Angle between a and b in real space (degrees)
+        tilt (float): Tilt angle of the lattice (degrees)
+        azimuth (float): Azimuthal angle of the tilt (degrees)
+    Returns:
+        dict: The qxy and qz scattering vectors for the first three peaks
+    """
+    gam_rad = np.deg2rad(gamma)
+    t3_rad = np.deg2rad(tilt)
+
+    # 1. Reverse A and B reciprocal relationships to get qxy1 (qx10) and qxy2 (qx01)
+    qx10 = 2 * np.pi / (a * np.sin(gam_rad))
+    qx01 = 2 * np.pi / (b * np.sin(gam_rad))
+
+    # 2. Calculate qxy3 (qx11) using the reciprocal space law of cosines
+    qx11 = np.sqrt(qx10**2 + qx01**2 - 2 * qx10 * qx01 * np.cos(gam_rad))
+
+    # 3. Reverse the azimuth logic
+    # azimuth3_deg = azimuth_internal_deg + (gam_deg - 90.0)
+    azimuth_internal_deg = azimuth - (gamma - 90.0)
+    azimuth_internal_rad = np.deg2rad(azimuth_internal_deg)
+
+    # 4. Reconstruct the normal vector components
+    nz = qx10 * qx01 * np.sin(gam_rad)
+
+    # Guard against perfectly vertical tilt dividing by zero
+    if np.cos(t3_rad) == 0.0:
+        return None
+
+    nmod = nz / np.cos(t3_rad)
+
+    # Extract nx and ny using the inverted azimuthal angles
+    nxy = np.sqrt(max(0, nmod**2 - nz**2))
+    nx = nxy * np.cos(azimuth_internal_rad)
+    ny = nxy * np.sin(azimuth_internal_rad)
+
+    # 5. Reverse the cross product equations to solve for qz10 and qz01
+    # nx = -qz10 * qx01 * sin(gamma)
+    qz10 = nx / (qx01 * np.sin(gam_rad))
+
+    # ny = -(qx10 * qz01 + qz10 * qx01 * cos(gamma))
+    qz01 = (-ny - qz10 * qx01 * np.cos(gam_rad)) / qx10
+
+    # 6. Reconstruct qz11 (assuming ideal constructive addition for the 1,1 peak)
+    qz11 = qz10 + qz01
+
+    return {
+        "qxy1": np.round(qx10, 5),
+        "qz1": np.round(qz10, 5),
+        "qxy2": np.round(qx01, 5),
+        "qz2": np.round(qz01, 5),
+        "qxy3": np.round(qx11, 5),
+        "qz3": np.round(qz11, 5)
+    }

sas/__init__.py

@@ -0,0 +1,2 @@
+from .sas import D11_SANS as D11_SANS
+from .sas import ID02_SAXS as ID02_SAXS

sas/sas.py

@@ -0,0 +1,96 @@
+import h5py
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class D11_SANS:
+
+    def __init__(self, filename, data=True):
+        self.q = np.array([])
+        self.I = np.array([])
+        self.I_err = np.array([])
+        self.q_err = np.array([])
+        self.q_fit = np.array([])
+        self.I_fit = np.array([])
+        self.sample_name = ''
+        if data:
+            self.load_data(filename)
+        else:
+            self.load_fit(filename)
+
+    def __repr__(self):
+        return self.sample_name
+
+    def get_sample_name(self):
+        return self.sample_name
+
+    def load_data(self, filename):
+        with open(filename, 'r') as f:
+            a = f.read()
+            self.sample_name = a.split('Subtitle:')[1].split('\n')[0].replace(' ', '')
+            data = np.loadtxt(filename, skiprows=53).T
+            self.q = data[0] * 10
+            self.I = data[1]
+            self.I_err = data[2]
+            self.q_err = data[3] * 10
+
+    def plot(self, ax=None, bckg=0.0, label=None):
+        if not ax:
+            _fig, ax = plt.subplots(1, 1)
+
+        if not label:
+            label = self.sample_name
+
+        if isinstance(bckg, float):
+            ax.errorbar(self.q, self.I - bckg, yerr=self.I_err, label=label, fmt='.', capsize=3, alpha=0.25)
+        else:
+            ax.errorbar(self.q, self.I - bckg.I, yerr=self.I_err, label=label, fmt='.', capsize=3, alpha=0.25)
+        ax.set_xlabel('$q, \\mathrm{nm}^{-1}$')
+        ax.set_ylabel('$\\mathrm{\\Delta}\\Sigma / \\mathrm{\\Delta}\\Omega, \\mathrm{cm}^{-1}$')
+        ax.loglog()
+        ax.legend()
+
+
+class ID02_SAXS:
+    def __init__(self, filename, data=True, sample_thickness=0.2):
+        self.q = np.array([])
+        self.I = np.array([])
+        self.I_err = np.array([])
+        self.q_fit = np.array([])
+        self.I_fit = np.array([])
+        self.sample_name = ''
+        self.sample_thickness = sample_thickness   # for 2 mm capillary to convert into 1/cm
+        if data:
+            self.load_data(filename)
+        else:
+            self.load_fit(filename)
+
+    def __repr__(self):
+        return self.sample_name
+
+    def load_fit(self, filename):
+        fit = np.loadtxt(filename).T
+        # print(fit)
+        self.q_fit = fit[0]
+        self.I_fit = fit[1]
+
+    def load_data(self, filename):
+        with h5py.File(filename, 'r') as file:
+            self.I = np.array(file['entry_0000']['saxsutilities']['data']['I'])[0] / self.sample_thickness
+            self.I_err = np.array(file['entry_0000']['saxsutilities']['data']['Idev'])[0] / self.sample_thickness
+            self.q = np.array(file['entry_0000']['saxsutilities']['data']['q'])
+            self.sample_name = str(file['entry_0000']['saxsutilities']['data']['header_array']['title'][()]).split("\'")[1]
+
+    def plot(self, ax=None, norm_factor=1, label=None):
+        if not ax:
+            _fig, ax = plt.subplots(1, 1)
+
+        if not label:
+            label = self.sample_name
+
+        ax.errorbar(self.q, self.I / norm_factor, self.I_err / norm_factor, fmt='o', capsize=2, linewidth=1,
+                    markersize=1, label=label)
+        ax.set_xlabel('$q, \\mathrm{nm}^{-1}$')
+        ax.set_ylabel('$\\mathrm{Intensity, cm}^{-1}$')
+        ax.legend()
+        ax.loglog()

scattools-0.0.1.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: ScatTools
+Version: 0.0.1
+Summary: Tools for X-ray and neutron scattering analysis
+Project-URL: Homepage, https://github.com/chelberserker/ScatTools/
+Author: Egor A. Bersenev
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# Scatter Analysis
+
+A Python package providing tools for the analysis of X-ray and neutron scattering data (SAXS, SANS, and GID).
+
+## Installation
+
+```bash
+pip install ScatTools
+```
+
+## Features
+
+- **GID**: Analysis of Grazing Incidence Diffraction data. Calculates crystallographic parameters based on scattering vectors.
+- **SAS**: Analysis of Small Angle Scattering data, including Small Angle X-ray Scattering (SAXS) and Small Angle Neutron Scattering (SANS) with support for plotting and data loading.
+
+## Documentation
+
+Documentation will be made available shortly.
+
+## Usage Example
+
+```python
+from gid import calculate_cell_parameters
+
+# Calculate parameters based on scattering vectors
+params = calculate_cell_parameters(qxy1=1.0, qxy2=1.0, qxy3=1.0, qz1=0.1, qz2=0.1, qz3=0.1)
+print(params)
+```

scattools-0.0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+gid/__init__.py,sha256=BI387EbIgn0VM5BDIe9-9GkikQHQCuSCjJGFVl5EFVg,130
+gid/gid.py,sha256=U2Bz8t6gMHXgJmQKjhfAbnlbfzFuATlhv6ehbqA6C_I,4703
+sas/__init__.py,sha256=Lg7qDwrybzkIHKDnsLtcMfzRkwT7bBIbqVxc-1rzdsc,78
+sas/sas.py,sha256=yjT6btsVIBfOWr3TlM-O2X7IQloua66HKV2IUz88cNw,3252
+scattools-0.0.1.dist-info/METADATA,sha256=GQyQrT7TSJjcCV6HDJd1z2mkZmPugDY4Fug4OYonDQw,1284
+scattools-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+scattools-0.0.1.dist-info/RECORD,,

scattools-0.0.1.dist-info/WHEEL

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