xrayscatteringtools 0.1.1__tar.gz → 0.2.0__tar.gz

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/LICENSE

@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrayscatteringtools
-Version: 0.1.1
+Version: 0.2.0
 Summary: A library for gas phase analysis at the CXI endstation
 Project-URL: Homepage, https://github.com/Weber-Group/xrayscatteringtools
 Project-URL: Issues, https://github.com/Weber-Group/xrayscatteringtools/issues
@@ -29,15 +29,22 @@ Description-Content-Type: text/markdown
 
 ## A python library for the analysis of data from the CXI endstation at the LCLS. 
 
+### `calib` submodule pertains to the geometry calibration routine
+
+### `theory` submodule pertains to stored ab initio patterns, iam, or geometries.
+### `utils` has a bunch of useful functions in it
+### `xrayscatteringtools.io` has anything pertaning to loading or writing data (`combineRuns` is in here)
+### `plotting` has anything to do with plotting.
+
 ### List of all methods:
-All methods have full docstrings in the NumPy docstring standard.
-Proper namespaces have yet to be defined. Some of these functions can remain internal, and the more useful ones can be defined at the surface level.
+All methods should have full docstrings in the NumPy docstring standard.
 * calib
   * geometry_calibration
     - run_geometry_calibration()
     - model()
     - thompson_correction()
     - geometry_correction()
+    - geometry_correction_units()
   * scattering_corrections
     - correction_factor()
     - Si_correction()
@@ -49,6 +56,7 @@ Proper namespaces have yet to be defined. Some of these functions can remain int
     - Al_attenuation_length()
     - Be_attenuation_length()
     - KaptonHN_attenuation_length()
+    - Zn_attenuation_length()
     - J4M_efficiency()
 * theory
   * iam
@@ -56,24 +64,40 @@ Proper namespaces have yet to be defined. Some of these functions can remain int
     - iam_inelastic_pattern()
     - iam_total_pattern()
     - iam_compton_spectrum()
+    - iam_elastic_pattern_oriented()
+    - iam_inelastic_pattern_oriented()
+    - iam_total_pattern_oriented()
   * patterns
-    - sf6()
+    - SF6__CCSD__aug_cc_pVDZ
+    - SF6__HF__aug_cc_pVDZ
+    - SF6__MP2__aug_cc_pVDZ
+  * geometries
+    - SF6__CCSD_T_DHK__aug_cc_pV5Z_DK 
 * io
   - combineRuns()
   - get_tree()
   - is_leaf()
   - get_leaves()
+  - get_data_paths()
   - runNumToString()
   - read_xyz()
+  - write_xyz()
+  - read_mol()
 * plotting
   - plot_jungfrau()
   - compute_pixel_edges()
 * utils
   - enable_underscore_cleanup()
   - azimuthalBinning()
+  - au2invAngstroms()
+  - invAngstroms2au()
   - keV2Angstroms()
   - Angstroms2keV()
   - q2theta()
   - theta2q()
   - element_symbol_to_number()
   - element_number_to_symbol()
+  - translate_molecule()
+  - rotate_molecule()
+  - J4M()
+  - 

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/README.md

@@ -2,15 +2,22 @@
 
 ## A python library for the analysis of data from the CXI endstation at the LCLS. 
 
+### `calib` submodule pertains to the geometry calibration routine
+
+### `theory` submodule pertains to stored ab initio patterns, iam, or geometries.
+### `utils` has a bunch of useful functions in it
+### `xrayscatteringtools.io` has anything pertaning to loading or writing data (`combineRuns` is in here)
+### `plotting` has anything to do with plotting.
+
 ### List of all methods:
-All methods have full docstrings in the NumPy docstring standard.
-Proper namespaces have yet to be defined. Some of these functions can remain internal, and the more useful ones can be defined at the surface level.
+All methods should have full docstrings in the NumPy docstring standard.
 * calib
   * geometry_calibration
     - run_geometry_calibration()
     - model()
     - thompson_correction()
     - geometry_correction()
+    - geometry_correction_units()
   * scattering_corrections
     - correction_factor()
     - Si_correction()
@@ -22,6 +29,7 @@ Proper namespaces have yet to be defined. Some of these functions can remain int
     - Al_attenuation_length()
     - Be_attenuation_length()
     - KaptonHN_attenuation_length()
+    - Zn_attenuation_length()
     - J4M_efficiency()
 * theory
   * iam
@@ -29,24 +37,40 @@ Proper namespaces have yet to be defined. Some of these functions can remain int
     - iam_inelastic_pattern()
     - iam_total_pattern()
     - iam_compton_spectrum()
+    - iam_elastic_pattern_oriented()
+    - iam_inelastic_pattern_oriented()
+    - iam_total_pattern_oriented()
   * patterns
-    - sf6()
+    - SF6__CCSD__aug_cc_pVDZ
+    - SF6__HF__aug_cc_pVDZ
+    - SF6__MP2__aug_cc_pVDZ
+  * geometries
+    - SF6__CCSD_T_DHK__aug_cc_pV5Z_DK 
 * io
   - combineRuns()
   - get_tree()
   - is_leaf()
   - get_leaves()
+  - get_data_paths()
   - runNumToString()
   - read_xyz()
+  - write_xyz()
+  - read_mol()
 * plotting
   - plot_jungfrau()
   - compute_pixel_edges()
 * utils
   - enable_underscore_cleanup()
   - azimuthalBinning()
+  - au2invAngstroms()
+  - invAngstroms2au()
   - keV2Angstroms()
   - Angstroms2keV()
   - q2theta()
   - theta2q()
   - element_symbol_to_number()
   - element_number_to_symbol()
+  - translate_molecule()
+  - rotate_molecule()
+  - J4M()
+  - 

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xrayscatteringtools"
-version = "0.1.1"
+version = "0.2.0"
 description = "A library for gas phase analysis at the CXI endstation"
 authors = [
     { name = "David Romano", email = "david_j_romano@brown.edu" }

xrayscatteringtools-0.2.0/src/xrayscatteringtools/__init__.py

@@ -0,0 +1,5 @@
+from .io import combineRuns, get_leaves, read_xyz, write_xyz, read_mol
+from .plotting import plot_jungfrau, compute_pixel_edges
+from .utils import enable_underscore_cleanup, azimuthalBinning, au2invAngstroms, invAngstroms2au, keV2Angstroms, Angstroms2keV, q2theta, theta2q, element_number_to_symbol, element_symbol_to_number, translate_molecule, rotate_molecule, J4M
+from . import theory
+from . import calib

xrayscatteringtools-0.2.0/src/xrayscatteringtools/calib/__init__.py

@@ -0,0 +1,2 @@
+from .geometry_calibration import run_geometry_calibration, model
+from .scattering_corrections import correction_factor, J4M_efficiency

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/src/xrayscatteringtools/calib/geometry_calibration.py

@@ -1,8 +1,8 @@
 import numpy as np
 from scipy.interpolate import InterpolatedUnivariateSpline
 from scipy.optimize import curve_fit
-from xrayscatteringtools.utils import theta2q
-from xrayscatteringtools.calib.scattering_corrections import correction_factor
+from ..utils import theta2q
+from .scattering_corrections import correction_factor
 
 def run_geometry_calibration(
         raw_image,
@@ -100,7 +100,22 @@ def run_geometry_calibration(
     fit = fitting_function([np.ravel(x), np.ravel(y)], *popt).reshape(raw_image.shape)
     return fit, popt, pcov
 
-def model(xy, amplitude, x0, y0, z0, phi0, photon_energy_keV, theory_interpolation):
+def model(
+        xy,
+        amplitude,
+        x0,
+        y0,
+        z0,
+        phi0,
+        photon_energy_keV,
+        theory_interpolation,
+        do_geometry_correction=True,
+        do_thompson_correction=True,
+        do_angle_of_scattering_correction=True,
+        do_geometry_correction_units=False,
+        dx=75,
+        dy=75
+        ):
     """
     Calculate the theoretical detector image for given geometry parameters.
 
@@ -118,12 +133,25 @@ def model(xy, amplitude, x0, y0, z0, phi0, photon_energy_keV, theory_interpolati
         Photon energy in keV.
     theory_interpolation : callable
         Interpolated function for theoretical scattering intensities versus q.
+    do_geometry_correction : bool, optional
+        If True, apply geometry correction. Default is True.
+    do_thompson_correction : bool, optional
+        If True, apply Thompson polarization correction. Default is True.
+    do_angle_of_scattering_correction : bool, optional
+        If True, apply angle-of-scattering correction. Default is True.
+    do_geometry_correction_units : bool, optional
+        If True, apply geometry accounting for proper solid angle subtension. Default is False.
+    dx, dy : float, optional
+        Pixel size in microns for geometry correction with units. Default is 75 microns. If do_geometry_correction_units is False, these are ignored.
 
     Returns
     -------
     fit : ndarray
         Flattened array of predicted intensities for each pixel.
 
+    Notes
+    -----
+    Do not use both do_geometry_correction and do_geometry_correction_units at the same time.
     """
     # Pull out the x and y arrays from the input
     x = xy[0]
@@ -138,9 +166,14 @@ def model(xy, amplitude, x0, y0, z0, phi0, photon_energy_keV, theory_interpolati
 
     # Calculate corrections
     corrections = np.ones_like(q_matrix)
-    corrections *= thompson_correction(centered_x, centered_y, z0, phi0) # Polarization
-    corrections *= geometry_correction(centered_x, centered_y, z0) # Geometry
-    corrections *= correction_factor(q_matrix, photon_energy_keV) # Angle-Of-Scattering, Lingyu Ma et al 2024 J. Phys. B: At. Mol. Opt. Phys. 57 205602
+    if do_thompson_correction:
+        corrections *= thompson_correction(centered_x, centered_y, z0, phi0) # Polarization
+    if do_geometry_correction:
+        corrections *= geometry_correction(centered_x, centered_y, z0) # Geometry
+    if do_angle_of_scattering_correction:
+        corrections *= correction_factor(q_matrix, photon_energy_keV) # Angle-Of-Scattering, Lingyu Ma et al 2024 J. Phys. B: At. Mol. Opt. Phys. 57 205602
+    if do_geometry_correction_units:
+        corrections *= geometry_correction_units(centered_x, centered_y, z0, dx, dy) # Geometry correctly accounting for solid angle subtension per pixel
     fit = amplitude * theory_interpolation(q_matrix) * corrections
     return fit
 
@@ -151,7 +184,7 @@ def thompson_correction(x, y, z0, phi0):
     Parameters
     ----------
     x, y : ndarray
-        Pixel coordinates relative to detector origin.
+        Pixel coordinates relative to signal origin.
     z0 : float
         Detector distance along beam axis.
     phi0 : float
@@ -181,7 +214,7 @@ def geometry_correction(x, y, z0):
     Parameters
     ----------
     x, y : ndarray
-        Pixel coordinates relative to detector origin.
+        Pixel coordinates relative to signal origin.
     z0 : float
         Detector distance along beam axis.
 
@@ -201,4 +234,32 @@ def geometry_correction(x, y, z0):
     r_matrix = np.sqrt(x**2 + y**2)
     theta = np.arctan(r_matrix / z0)
     correction = np.cos(theta) ** 3
+    return correction
+
+def geometry_correction_units(x, y, z0, dx, dy):
+    """
+    Compute geometric correction factor z0^2 cos^3(theta) / dxdy for a detector, accounting for pixel area and distance units.
+    
+    Parameters
+    ----------
+    x, y : ndarray
+        Pixel coordinates relative to signal origin.
+    z0 : float
+        Detector distance along beam axis.
+    dx, dy : float
+        Pixel size in x and y directions.
+    
+    Returns
+    -------
+    correction : ndarray
+        Geometric correction factor for each pixel.
+
+    Notes
+    -----
+    The geometry correction comes from the inverse square law and the effective area of the pixel.
+    The inverse square law accounts for z^2 cos^2(theta), and the effective area is cos(theta)/dxdy.
+    """
+    r_matrix = np.sqrt(x**2 + y**2)
+    theta = np.arctan(r_matrix / z0)
+    correction = np.cos(theta)**3 * (dx * dy) / z0**2
     return correction

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/src/xrayscatteringtools/calib/scattering_corrections.py

@@ -1,5 +1,5 @@
 from scipy.interpolate import InterpolatedUnivariateSpline
-from xrayscatteringtools.utils import q2theta
+from ..utils import q2theta
 import numpy as np
 import pathlib
 _data_path = pathlib.Path(__file__).parent / "data"
@@ -481,7 +481,7 @@ def Zn_attenuation_length(keV):
     Uses spline interpolation of tabulated attenuation lengths (in microns),
     then converts them to meters.
     """
-    with h5py.File('Zn_attenuation_length.h5', 'r') as f:
+    with h5py.File(f"{_data_path}/Zn_attenuation_length.h5", 'r') as f:
         E_values = f['E_values'][:]
         length = f['length'][:]
     Mu_Spline = InterpolatedUnivariateSpline(E_values, length)

{xrayscatteringtools-0.1.1 → xrayscatteringtools-0.2.0}/src/xrayscatteringtools/io.py

@@ -1,10 +1,9 @@
 import numpy as np
 import h5py
-from tqdm.auto import tqdm
-from xrayscatteringtools.epicsArch import EpicsArchive
+from .epicsArch import EpicsArchive
 from scipy.interpolate import interp1d
 import yaml
-from xrayscatteringtools.utils import element_number_to_symbol
+from .utils import element_number_to_symbol
 
 def combineRuns(runNumbers, folders, keys_to_combine, keys_to_sum, keys_to_check, verbose=False, archImport=False):
     """
@@ -55,6 +54,7 @@ def combineRuns(runNumbers, folders, keys_to_combine, keys_to_sum, keys_to_check
         If multiple folders are provided but the number of folders does not match
         the number of run numbers.
     """
+    from tqdm.auto import tqdm # Lazy
     # Ensure runNumbers is a list
     if not isinstance(runNumbers, (list, tuple)):
         runNumbers = [runNumbers]
@@ -172,7 +172,7 @@ def is_leaf(dataset):
     """
     return isinstance(dataset, h5py.Dataset)
 
-def get_leaves(f, saveto, verbose=False):
+def get_leaves(f, saveto=None, verbose=False):
     """Retrieve all leaf datasets from an HDF5 file and save them to a dictionary.
 
     Parameters
@@ -193,7 +193,8 @@ def get_leaves(f, saveto, verbose=False):
         if is_leaf(f[name]):
             if verbose:
                 print(name, f[name][()].shape)
-            saveto[name] = f[name][()]
+            if saveto is not None:
+                saveto[name] = f[name][()]
     f.visit(return_leaf)
 
 def get_data_paths(run_numbers, config_path='config.yaml'):
@@ -332,4 +333,111 @@ def write_xyz(filename, comment, atoms, coords):
         f.write(f"{len(atoms)}\n")
         f.write(f"{comment}\n")
         for atom, (x, y, z) in zip(atoms, coords):
-            f.write(f"{atom} {x:.6f} {y:.6f} {z:.6f}\n")
+            f.write(f"{atom} {x:.6f} {y:.6f} {z:.6f}\n")
+
+def read_mol(filename):
+    """
+    Read a molecular structure from a MOL file (MDL Molfile format).
+
+    Parameters
+    ----------
+    filename : str
+        Path to the MOL file to be read.
+
+    Returns
+    -------
+    molecule_name : str
+        Name of the molecule (first line of the file).
+    program_info : str
+        Program/user information (second line).
+    comment : str
+        Comment line (third line).
+    num_atoms : int
+        Number of atoms in the molecule.
+    num_bonds : int
+        Number of bonds in the molecule.
+    atoms : list of str
+        List of atomic symbols for each atom.
+    coords : list of tuple of float
+        Cartesian coordinates of each atom as (x, y, z) in Angstroms.
+    bonds : list of tuple of int
+        List of bonds as (atom1_index, atom2_index, bond_type).
+        Atom indices are 1-based as in the MOL file.
+        Bond types: 1=single, 2=double, 3=triple, 4=aromatic.
+    properties : dict
+        Additional properties from the atom and bond blocks.
+        - 'atom_properties': list of dicts with mass_diff, charge, stereo_parity, etc.
+        - 'bond_properties': list of dicts with stereo, topology, etc.
+
+    Notes
+    -----
+    The MOL file format (V2000) is expected to have:
+    1. Line 1: Molecule name
+    2. Line 2: Program/user info and timestamp
+    3. Line 3: Comment
+    4. Line 4: Counts line (atoms, bonds, etc.)
+    5. Atom block: one line per atom with coordinates and properties
+    6. Bond block: one line per bond
+    7. Properties block (optional)
+    """
+    with open(filename, 'r') as f:
+        lines = f.readlines()
+    
+    # Header block (first 3 lines)
+    molecule_name = lines[0].strip()
+    program_info = lines[1].strip()
+    comment = lines[2].strip()
+    
+    # Counts line (line 4)
+    counts_line = lines[3]
+    num_atoms = int(counts_line[0:3].strip())
+    num_bonds = int(counts_line[3:6].strip())
+    
+    # Atom block
+    atoms = []
+    coords = []
+    atom_properties = []
+    
+    for i in range(4, 4 + num_atoms):
+        line = lines[i]
+        x = float(line[0:10].strip())
+        y = float(line[10:20].strip())
+        z = float(line[20:30].strip())
+        element = line[31:34].strip()
+        
+        # Additional atom properties
+        mass_diff = int(line[34:36].strip()) if len(line) > 34 and line[34:36].strip() else 0
+        charge = int(line[36:39].strip()) if len(line) > 36 and line[36:39].strip() else 0
+        
+        atoms.append(element)
+        coords.append((x, y, z))
+        atom_properties.append({
+            'mass_diff': mass_diff,
+            'charge': charge
+        })
+    
+    # Bond block
+    bonds = []
+    bond_properties = []
+    
+    bond_start = 4 + num_atoms
+    for i in range(bond_start, bond_start + num_bonds):
+        line = lines[i]
+        atom1 = int(line[0:3].strip())
+        atom2 = int(line[3:6].strip())
+        bond_type = int(line[6:9].strip())
+        
+        # Additional bond properties
+        stereo = int(line[9:12].strip()) if len(line) > 9 and line[9:12].strip() else 0
+        
+        bonds.append((atom1, atom2, bond_type))
+        bond_properties.append({
+            'stereo': stereo
+        })
+    
+    properties = {
+        'atom_properties': atom_properties,
+        'bond_properties': bond_properties
+    }
+    
+    return molecule_name, program_info, comment, num_atoms, num_bonds, atoms, coords, bonds, properties

xrayscatteringtools-0.2.0/src/xrayscatteringtools/theory/__init__.py

@@ -0,0 +1,7 @@
+from .iam import iam_total_pattern, iam_elastic_pattern, iam_inelastic_pattern
+from .iam import iam_total_pattern_oriented, iam_elastic_pattern_oriented, iam_inelastic_pattern_oriented
+from .iam import iam_compton_spectrum
+
+from .geometries import SF6__CCSD_T_DHK__aug_cc_pV5Z_DK
+
+from .patterns import SF6__CCSD__aug_cc_pVDZ, SF6__MP2__aug_cc_pVDZ, SF6__HF__aug_cc_pVDZ

xrayscatteringtools-0.2.0/src/xrayscatteringtools/theory/data/geometries/make_geometry_h5.py

@@ -0,0 +1,38 @@
+import h5py
+import numpy as np
+
+# Naming convention "Molecule__Method__Basis__Extras"
+filename = "SF6__CCSD_T_DHK__aug_cc_pV5Z_DK"
+molecule = "SF6"
+method = "CCSD(T)+DHK"
+basis_set = "aug-cc-pV5Z-DK"
+n_electrons = 70
+energy = -998.01159357
+notes = "+DKH means that scalar-relativistic corrections via a tenth-order Douglas-Kroll-Hess Hamiltonian are included. This is also reflected by the -DK in the basis set. Mats Simmermacher sent over on Nov 17, 2025."
+atoms = ['S', 'F', 'F', 'F', 'F', 'F', 'F']
+charge = 0
+geometry = np.array([
+    [ 0.0000000000,  0.0000000000,  0.0000000000],
+    [ 0.0000000000,  0.0000000000,  1.5600310790],
+    [ 0.0000000000,  0.0000000000, -1.5600310790],
+    [ 0.0000000000,  1.5600310790,  0.0000000000],
+    [ 0.0000000000, -1.5600310790,  0.0000000000],
+    [ 1.5600310790,  0.0000000000,  0.0000000000],
+    [-1.5600310790,  0.0000000000,  0.0000000000]
+    ])
+
+# Creating the file and saving it
+with h5py.File(filename + ".h5", "w") as f:
+
+    # Attributes
+    f.attrs["molecule"] = molecule
+    f.attrs["method"] = method
+    f.attrs["basis_set"] = basis_set
+    f.attrs["n_electrons"] = n_electrons
+    f.attrs["energy"] = energy
+    f.attrs["notes"] = notes
+    f.attrs["charge"] = charge
+    f.attrs["atoms"] = atoms
+
+    # Datasets
+    f.create_dataset("geometry", data=geometry)

{xrayscatteringtools-0.1.1/tests → xrayscatteringtools-0.2.0/src/xrayscatteringtools/theory/data/patterns}/convert_ab_initio_to_h5.py

@@ -17,7 +17,7 @@ molecule = "SF6"
 method = "HF"
 basis_set = "aug_cc_pVDZ"
 ##################### End User Set Parameters #####################
-h5_filename = f"{molecule}_{method}_{basis_set}.h5"
+h5_filename = f"{molecule}__{method}__{basis_set}.h5"
 
 # Current conversion from a.u. to 1/Angstrom
 conversion_factor = au2invAngstroms(1.0)

xrayscatteringtools-0.2.0/src/xrayscatteringtools/theory/geometries.py

@@ -0,0 +1,92 @@
+from types import SimpleNamespace
+import h5py
+import pathlib
+
+# Generally the import names go like 'molecule_method_basisset' Put all available names in __all__. These should match the .h5 files in the data directory.
+__all__ = [
+    'SF6__CCSD_T_DHK__aug_cc_pV5Z_DK'
+    ]
+def __dir__():
+    # Tab completion for IPython
+    return sorted(__all__)
+
+
+_data_path = pathlib.Path(__file__).parent / "data/geometries"
+
+def __getattr__(name):
+    if name in __all__:
+        # Load from HDF5 only when first accessed
+        with h5py.File(f"{_data_path}/{name}.h5", "r") as f:
+            obj = _make_default_obj(f)
+        obj.__doc__ = _make_default_docstring(obj)
+        return obj
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+def _make_default_obj(f):
+    """
+    Create a SimpleNamespace object with default attributes from an HDF5 file.
+
+    Parameters
+    ----------
+    f : h5py.File
+        An open HDF5 file object containing the datasets and attributes.
+
+    Returns
+    -------
+    obj : SimpleNamespace
+        A SimpleNamespace object with attributes: geometry, molecule, method, basis_set, n_electrons, charge, energy, atoms,  notes.
+    """
+    return SimpleNamespace(
+        geometry=f["geometry"][:],
+        molecule=f.attrs["molecule"],
+        method=f.attrs["method"],
+        basis_set=f.attrs["basis_set"],
+        n_electrons=f.attrs["n_electrons"],
+        charge=f.attrs["charge"],
+        energy=f.attrs["energy"],
+        atoms=f.attrs["atoms"],
+        notes=f.attrs["notes"]
+        )
+
+def _make_default_docstring(obj):
+    """
+    Generate a default docstring for a geometry object.
+
+    Parameters
+    ----------
+    obj : SimpleNamespace
+        The data object with attributes: geometry, molecule, method, basis_set, n_electrons.
+
+    Returns
+    -------
+    doc : str
+        The generated docstring.
+    """
+
+    doc = f"""
+    Optimized geometry for {obj.molecule} at the {obj.method}/{obj.basis_set} level of theory.
+
+    Attributes
+    ----------
+    geometry : Nx3 numpy array
+        The geometry data of the molecule, in Angstroms.
+    atoms : list of str
+        The list of atomic symbols corresponding to the geometry.
+    molecule : str
+        The molecular formula of the species.
+    method : str
+        The method used for the calculation.
+    basis_set : str
+        The basis set used for the calculation.
+    n_electrons : int
+        The number of electrons in the molecule.
+    charge : int
+        The net charge of the molecule.
+    energy : float
+        The total electronic energy of the molecule in Hartree.
+
+    Notes
+    -----
+    {obj.notes}
+    """
+    return doc

xrayscatteringtools-0.2.0/src/xrayscatteringtools/theory/geometries.pyi

@@ -0,0 +1,17 @@
+from types import SimpleNamespace
+
+__all__: list[str]
+
+class _GeometryData(SimpleNamespace):
+    """Type stub for ab initio geometry data."""
+    geometry: any  # ndarray
+    molecule: str
+    method: str
+    basis_set: str
+    n_electrons: int
+    charge: int
+    energy: float
+    atoms: list[str]
+    notes: str
+
+SF6__CCSD_T_DHK__aug_cc_pV5Z_DK: _GeometryData