md-exafs 0.2.0__py3-none-any.whl

md_exafs/__init__.py

@@ -0,0 +1,56 @@
+"""MD-EXAFS Core Engine - Trajectory analysis and path-resolved EXAFS reconstruction."""
+
+from pathlib import Path
+
+from .constants import ETOK, HBAR2_OVER_2M_EV_ANGSTROM2
+from .exafs_data import PathAggregator, PathContribution
+from .feff_input import FeffConfig, build_feff_inp, normalize_tag
+from .hdf5 import (
+    ArchiveReader,
+    BatchShardReader,
+    BatchShardWriter,
+    EnsembleReader,
+    EnsembleWriter,
+    ExafsHDF5Store,
+)
+from .paths import PathResult, make_path_key, path_chi
+from .potentials import PotentialsManager
+from .selection import (
+    parse_frame_slice,
+    resolve_frame_absorbers,
+    resolve_trajectory_absorbers,
+)
+from .spectra import average_chi_arrays, format_chi_ascii, xftf_arrays
+
+__version__ = "0.2.0"
+
+# Default cache directory for FEFF calculations and results
+DEFAULT_CACHE_DIR = Path.home() / ".larch_cache"
+
+__all__ = [
+    "__version__",
+    "DEFAULT_CACHE_DIR",
+    "HBAR2_OVER_2M_EV_ANGSTROM2",
+    "ETOK",
+    "FeffConfig",
+    "build_feff_inp",
+    "normalize_tag",
+    "PathResult",
+    "path_chi",
+    "make_path_key",
+    "xftf_arrays",
+    "average_chi_arrays",
+    "format_chi_ascii",
+    "resolve_frame_absorbers",
+    "resolve_trajectory_absorbers",
+    "parse_frame_slice",
+    "PotentialsManager",
+    "BatchShardWriter",
+    "BatchShardReader",
+    "EnsembleWriter",
+    "EnsembleReader",
+    "ArchiveReader",
+    "ExafsHDF5Store",
+    "PathAggregator",
+    "PathContribution",
+]

md_exafs/__main__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""Entry point for the larch CLI wrapper."""
+
+from larch_cli_wrapper.cli import app
+
+if __name__ == "__main__":
+    app()

md_exafs/cache_utils.py

@@ -0,0 +1,84 @@
+"""Cache utilities for EXAFS processing pipeline."""
+
+import hashlib
+import pickle
+import warnings
+from pathlib import Path
+from typing import Any
+
+from ase import Atoms
+
+
+def get_structure_hash(atoms: Atoms) -> str:
+    """Generate a hash for atomic structure for caching purposes."""
+    return hashlib.md5(  # noqa: S324
+        str(atoms.get_positions()).encode() + str(atoms.get_chemical_symbols()).encode()
+    ).hexdigest()[:16]
+
+
+def load_from_cache(
+    cache_key: str, cache_dir: str | Path | None, force_recalculate: bool = False
+) -> tuple[Any, Any] | None:
+    """Load cached results if available and not forcing recalculation.
+
+    Args:
+        cache_key: Unique identifier for the cached data
+        cache_dir: Directory where cache files are stored
+        force_recalculate: If True, ignore existing cache and return None
+
+    Returns:
+        Tuple of (k, chi) arrays if cache hit, None if cache miss or error
+
+    Note:
+        The returned chi array is complex (EXAFS chi(k) data) and k array
+        is real-valued k-space values.
+    """
+    if not cache_dir:
+        return None
+    cache_file = Path(cache_dir) / f"{cache_key}.pkl"
+    if cache_file.exists() and not force_recalculate:
+        try:
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)  # noqa: S301 - controlled usage
+            return cached_data["k"], cached_data["chi"]
+        except (EOFError, pickle.UnpicklingError, KeyError):
+            try:
+                cache_file.unlink()
+            except OSError:
+                # If we can't delete the cache file, just let the user know
+                warnings.warn(
+                    f"Failed to delete cache file {cache_file}",
+                    UserWarning,
+                    stacklevel=2,
+                )
+    return None
+
+
+def save_to_cache(
+    cache_key: str, chi: Any, k: Any, cache_dir: str | Path | None
+) -> None:
+    """Save processing results to cache for future use.
+
+    Args:
+        cache_key: Unique identifier for the cached data
+        chi: EXAFS chi(k) data (complex numpy array)
+        k: k-space values (real numpy array)
+        cache_dir: Directory where cache files are stored
+
+    Note:
+        Always stores complex chi data directly. Silently continues on cache
+        write failures with a warning.
+    """
+    if not cache_dir:
+        return
+    cache_file = Path(cache_dir) / f"{cache_key}.pkl"
+    cache_file.parent.mkdir(parents=True, exist_ok=True)
+    cached_data = {"chi": chi, "k": k}
+    try:
+        with open(cache_file, "wb") as f:
+            pickle.dump(cached_data, f)
+    except OSError:
+        # If we can't write to cache, continue without caching but inform the user
+        warnings.warn(
+            f"Failed to write cache file {cache_file}", UserWarning, stacklevel=2
+        )