diffpes 2026.3.1__py3-none-any.whl

diffpes/utils/math.py

@@ -0,0 +1,255 @@
+"""Mathematical utility functions for ARPES simulations.
+
+Extended Summary
+----------------
+Provides JAX-compatible implementations of the Faddeeva function
+(complex error function) and data normalization routines used
+throughout the ARPES simulation pipeline.
+
+Routine Listings
+----------------
+:func:`faddeeva`
+    Faddeeva function via Taylor series expansion.
+:func:`zscore_normalize`
+    Z-score (zero-mean, unit-variance) normalization.
+
+Notes
+-----
+The Faddeeva implementation uses a 64-term Taylor series
+derived from the ODE w'(z) = -2z w(z) + 2i/sqrt(pi),
+giving double-precision accuracy for |z| < 6.
+"""
+
+import math
+
+import jax
+import jax.numpy as jnp
+from beartype import beartype
+from jaxtyping import Array, Complex, Float, Int, jaxtyped
+
+_N_TAYLOR: int = 64
+
+
+def _faddeeva_taylor_coeffs() -> Complex[Array, " N"]:
+    r"""Taylor coefficients of w(z) = exp(-z^2) erfc(-iz) via JAX scan.
+
+    Extended Summary
+    ----------------
+    Computes the first ``_N_TAYLOR`` coefficients of the Taylor expansion
+    of the Faddeeva function about the origin.
+
+    **Mathematical derivation:**
+
+    The Faddeeva function satisfies the ODE:
+
+    .. math::
+
+        w'(z) = -2z \, w(z) + \frac{2i}{\sqrt{\pi}}
+
+    Substituting the power series ansatz :math:`w(z) = \sum_{n=0}^\infty
+    a_n z^n` and matching coefficients of :math:`z^n` on both sides
+    yields the two-term recurrence:
+
+    .. math::
+
+        a_0 = 1, \quad a_1 = \frac{2i}{\sqrt{\pi}}, \quad
+        a_{n+1} = \frac{-2 \, a_{n-1}}{n+1} \quad (n \ge 1)
+
+    Note that the recurrence couples even-indexed coefficients among
+    themselves and odd-indexed coefficients among themselves (the
+    series separates into even and odd parts). Even coefficients are
+    real and odd coefficients are purely imaginary, reflecting the
+    symmetry :math:`w(-z) = 2 e^{-z^2} - w(z)`.
+
+    **Implementation:**
+
+    The recurrence is implemented with ``jax.lax.scan`` (no Python
+    for-loop) for efficiency and XLA compatibility. The scan carry
+    is the pair :math:`(a_{n-1}, a_n)`, and at each step n (0-indexed),
+    the next coefficient is :math:`a_{n+2} = -2 a_n / (n + 2)`. The
+    scan produces coefficients :math:`a_2` through :math:`a_{N-1}`,
+    which are concatenated with the seed values :math:`a_0, a_1` to
+    form the complete coefficient vector.
+
+    The resulting array is reversed (descending power order) at module
+    level and stored in ``_W_POLY`` for use with ``jnp.polyval``
+    (Horner's method).
+
+    Returns
+    -------
+    coeffs : Complex[Array, " N"]
+        Taylor coefficients :math:`[a_0, a_1, \ldots, a_{N-1}]` in
+        ascending power order, where ``N = _N_TAYLOR``.
+    """
+    c0: Complex[Array, " "] = jnp.array(1.0 + 0j, dtype=jnp.complex128)
+    c1: Complex[Array, " "] = jnp.array(
+        2.0j / math.sqrt(math.pi), dtype=jnp.complex128
+    )
+
+    def body(
+        carry: tuple[Complex[Array, " "], Complex[Array, " "]],
+        n: Int[Array, ""],
+    ) -> tuple[
+        tuple[Complex[Array, " "], Complex[Array, " "]],
+        Complex[Array, " "],
+    ]:
+        c_prev, c_curr = carry
+        next_c: Complex[Array, " "] = (-2.0 * c_prev) / (
+            jnp.asarray(n, dtype=jnp.float64) + 2.0
+        )
+        return (c_curr, next_c), next_c
+
+    rest: Complex[Array, " N2"]
+    _, rest = jax.lax.scan(
+        body,
+        (c0, c1),
+        jnp.arange(_N_TAYLOR - 2, dtype=jnp.int32),
+    )
+    full: Complex[Array, " N"] = jnp.concatenate([c0[None], c1[None], rest])
+    return full
+
+
+_W_POLY: Complex[Array, " N"] = _faddeeva_taylor_coeffs()[::-1]
+
+
+@jaxtyped(typechecker=beartype)
+def faddeeva(
+    z: Complex[Array, " ..."],
+) -> Complex[Array, " ..."]:
+    r"""Evaluate the Faddeeva function w(z) = exp(-z^2) erfc(-iz).
+
+    Extended Summary
+    ----------------
+    Computes the Faddeeva (scaled complex complementary error) function
+    for arbitrary complex arrays using a precomputed Taylor polynomial
+    evaluated via Horner's method.
+
+    The Faddeeva function is defined as:
+
+    .. math::
+
+        w(z) = e^{-z^2} \operatorname{erfc}(-iz)
+             = e^{-z^2} \left(1 + \frac{2i}{\sqrt{\pi}}
+               \int_0^z e^{t^2} dt \right)
+
+    It is closely related to the Voigt profile used in spectroscopy:
+    the Voigt function is the real part of the Faddeeva function
+    evaluated along the imaginary axis. In ARPES simulations, it
+    appears when convolving Lorentzian lifetime broadening with
+    Gaussian instrumental resolution.
+
+    **Implementation:**
+
+    1. **Cast to complex128** -- convert the input to ``jnp.complex128``
+       via ``jnp.asarray`` to ensure sufficient precision for the 64-term
+       polynomial evaluation.
+
+    2. **Evaluate via Horner's method** -- call ``jnp.polyval`` with
+       the module-level constant ``_W_POLY`` (coefficients stored in
+       descending-power order, i.e. reversed from the natural
+       :math:`a_0, \ldots, a_{N-1}` ordering) and the cast input. The
+       ``unroll=8`` hint allows XLA to pipeline the inner loop for
+       better throughput on accelerators.
+
+    The Taylor coefficients are derived from the ODE
+    :math:`w'(z) = -2z w(z) + 2i/\sqrt{\pi}` and precomputed at
+    module import time by `_faddeeva_taylor_coeffs`. See that
+    function's docstring for the full recurrence derivation.
+
+    Parameters
+    ----------
+    z : Complex[Array, " ..."]
+        Complex argument(s), arbitrary shape.
+
+    Returns
+    -------
+    w : Complex[Array, " ..."]
+        Faddeeva function values, same shape as ``z``.
+
+    Notes
+    -----
+    Accuracy is approximately double-precision (~15 significant digits)
+    for |z| < 6. For |z| >= 6 the Taylor series converges slowly and
+    an asymptotic expansion or continued-fraction representation should
+    be used instead. The current implementation does **not** fall back
+    to an asymptotic form, so callers must ensure inputs stay within the
+    convergence domain.
+
+    The function is fully differentiable via JAX autodiff, which
+    is important for gradient-based optimization of broadening
+    parameters in inverse-fitting workflows.
+    """
+    z_c: Complex[Array, " ..."] = jnp.asarray(z, dtype=jnp.complex128)
+    w: Complex[Array, " ..."] = jnp.polyval(_W_POLY, z_c, unroll=8)
+    return w
+
+
+@jaxtyped(typechecker=beartype)
+def zscore_normalize(
+    data: Float[Array, " ..."],
+) -> Float[Array, " ..."]:
+    r"""Apply z-score normalization (zero-mean, unit-variance).
+
+    Extended Summary
+    ----------------
+    Transforms an arbitrary float array so that the output has zero mean
+    and unit standard deviation, which is a common preprocessing step
+    before comparing simulated and experimental ARPES spectra. The
+    z-score transformation is:
+
+    .. math::
+
+        \hat{x}_i = \frac{x_i - \bar{x}}{\sigma}
+
+    where :math:`\bar{x}` is the global mean and :math:`\sigma` is
+    the population standard deviation (:math:`\text{ddof}=0`).
+
+    **Implementation details:**
+
+    1. **Compute statistics** -- calculate the global mean and standard
+       deviation of the input array using ``jnp.mean`` and ``jnp.std``
+       (population std, i.e. ddof=0).
+
+    2. **Guard against zero std** -- if the standard deviation is
+       exactly zero (constant array), replace it with 1.0 via
+       ``jnp.where(std > 0, std, 1.0)`` to avoid division-by-zero.
+       This produces an all-zeros output for constant inputs, which is
+       the mathematically sensible limit. The ``jnp.where`` formulation
+       is gradient-safe: JAX will not propagate gradients through the
+       zero-std branch.
+
+    3. **Normalize** -- compute ``(data - mean) / safe_std`` element-wise
+       and return.
+
+    Parameters
+    ----------
+    data : Float[Array, " ..."]
+        Input data array of any shape.
+
+    Returns
+    -------
+    normalized : Float[Array, " ..."]
+        Normalized data with mean 0 and standard deviation 1
+        (or all zeros if the input is constant).
+
+    Notes
+    -----
+    The normalization is computed over **all** elements (global mean
+    and std), not per-axis. For per-axis normalization, reshape the
+    data and call this function on each slice separately.
+
+    This function is differentiable via JAX autodiff with respect to
+    the input ``data``. The gradient propagates through both the
+    mean-subtraction and the division by standard deviation.
+    """
+    mean_val: Float[Array, " "] = jnp.mean(data)
+    std_val: Float[Array, " "] = jnp.std(data)
+    safe_std: Float[Array, " "] = jnp.where(std_val > 0.0, std_val, 1.0)
+    normalized: Float[Array, " ..."] = (data - mean_val) / safe_std
+    return normalized
+
+
+__all__: list[str] = [
+    "faddeeva",
+    "zscore_normalize",
+]

diffpes-2026.3.1.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.3
+Name: diffpes
+Version: 2026.3.1
+Summary: Differentiable ARPES simulations in JAX
+Keywords: ARPES,MBE,JAX,Differentiable Programming
+Author: Debangshu Mukherjee, Jacob Cook
+Author-email: Debangshu Mukherjee <mukherjeed@ornl.gov>, Jacob Cook <cookjl2@ornl.gov>
+License: MIT License
+         
+         Copyright (c) 2026 Debangshu Mukherjee, Oak Ridge National Laboratory
+         
+         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.
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Dist: numpy>=2.2.1
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: jax>=0.7.0 ; sys_platform == 'win64'
+Requires-Dist: jax>=0.7.0 ; sys_platform == 'darwin'
+Requires-Dist: jax>=0.7.0 ; sys_platform == 'linux'
+Requires-Dist: jaxtyping>=0.3.0
+Requires-Dist: chex>=0.1.85
+Requires-Dist: beartype>=0.21.0
+Requires-Dist: jupyter>=1.1.1
+Requires-Dist: ipykernel>=7.2.0
+Requires-Dist: h5py>=3.15.1
+Requires-Dist: diffpes[docs,test,dev,notebooks,cuda] ; extra == 'all'
+Requires-Dist: jax[cuda12]>=0.7.0 ; platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'cuda'
+Requires-Dist: nvidia-cudnn-cu12>=9.5.0 ; platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'cuda'
+Requires-Dist: diffpes[docs,test,notebooks] ; extra == 'dev'
+Requires-Dist: black[jupyter]>=25.1.0 ; extra == 'dev'
+Requires-Dist: build>=1.2.2.post1 ; extra == 'dev'
+Requires-Dist: twine>=6.1.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.12.9 ; extra == 'dev'
+Requires-Dist: pygount>=3.1.0 ; extra == 'dev'
+Requires-Dist: pre-commit>=4.5.1 ; extra == 'dev'
+Requires-Dist: isort>=6.0.1 ; extra == 'dev'
+Requires-Dist: ty>=0.0.19 ; extra == 'dev'
+Requires-Dist: black>=26.1.0 ; extra == 'dev'
+Requires-Dist: jupyter-black>=0.4.0 ; extra == 'dev'
+Requires-Dist: diffpes[dev,cuda] ; extra == 'dev-cuda'
+Requires-Dist: sphinx>=7.0.0 ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=3.0.2 ; extra == 'docs'
+Requires-Dist: nbsphinx>=0.9.7 ; extra == 'docs'
+Requires-Dist: myst-parser>=2.0.0 ; extra == 'docs'
+Requires-Dist: ipykernel>=6.29.5 ; extra == 'docs'
+Requires-Dist: nbconvert>=7.16.6 ; extra == 'docs'
+Requires-Dist: furo>=2025.7.19 ; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=3.0.1 ; extra == 'docs'
+Requires-Dist: numpydoc>=1.9.0 ; extra == 'docs'
+Requires-Dist: pydoclint>=0.7.3 ; extra == 'docs'
+Requires-Dist: interrogate>=1.7.0 ; extra == 'docs'
+Requires-Dist: ipywidgets>=8.1.0 ; extra == 'notebooks'
+Requires-Dist: ipykernel>=6.29.5 ; extra == 'notebooks'
+Requires-Dist: nbconvert>=7.16.6 ; extra == 'notebooks'
+Requires-Dist: pytest>=8.3.5 ; extra == 'test'
+Requires-Dist: pytest-cov>=6.0.0 ; extra == 'test'
+Requires-Dist: pytest-xdist>=3.0.0 ; extra == 'test'
+Requires-Dist: chex>=0.1.89 ; extra == 'test'
+Maintainer: Debangshu Mukherjee
+Maintainer-email: Debangshu Mukherjee <mukherjeed@ornl.gov>
+Requires-Python: >=3.12, <3.15
+Provides-Extra: all
+Provides-Extra: cuda
+Provides-Extra: dev
+Provides-Extra: dev-cuda
+Provides-Extra: docs
+Provides-Extra: notebooks
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+# diffpes
+
+JAX-based ARPES simulation toolkit with Python-native APIs.
+
+## Expanded-input workflows
+
+The package includes expanded-input wrappers that let you call the
+simulator with plain arrays/scalars while still running JAX kernels.
+
+### Function mapping
+
+- `ARPES_simulation_Novice` -> `diffpes.simul.simulate_novice_expanded`
+- `ARPES_simulation_Basic` -> `diffpes.simul.simulate_basic_expanded`
+- `ARPES_simulation_Basicplus` -> `diffpes.simul.simulate_basicplus_expanded`
+- `ARPES_simulation_Advanced` -> `diffpes.simul.simulate_advanced_expanded`
+- `ARPES_simulation_Expert` -> `diffpes.simul.simulate_expert_expanded`
+- `ARPES_simulation_SOC` -> `diffpes.simul.simulate_soc_expanded`
+- Dynamic dispatch by level -> `diffpes.simul.simulate_expanded`
+  (use `level="soc"` with `surface_spin` for SOC)
+
+### Notes
+
+- Default energy-axis padding behavior:
+  `min(eigenbands)-1` to `max(eigenbands)+1`.
+- Incident angles for expanded wrappers are interpreted in degrees.
+- Wrappers return the standard `ArpesSpectrum` PyTree.
+
+### Python indexing conventions
+
+Use standard Python/NumPy indexing everywhere (zero-based, end-exclusive).
+
+- Non-s orbitals: `slice(1, 9)` -> indices 1..8
+- p orbitals: `slice(1, 4)` -> indices 1..3
+- d orbitals: `slice(4, 9)` -> indices 4..8
+
+Do not use MATLAB-style indexing notation in Python code.
+
+### Example
+
+```python
+import jax.numpy as jnp
+
+from diffpes.simul import simulate_expanded
+
+# [nkpt, nband]
+eigenbands = jnp.linspace(-2.0, 0.5, 100).reshape(20, 5)
+# [nkpt, nband, natom, 9]
+surface_orb = jnp.ones((20, 5, 2, 9)) * 0.1
+
+spectrum = simulate_expanded(
+    level="advanced",
+    eigenbands=eigenbands,
+    surface_orb=surface_orb,
+    ef=0.0,
+    sigma=0.04,
+    fidelity=2500,
+    temperature=15.0,
+    photon_energy=11.0,
+    polarization="unpolarized",
+    incident_theta=45.0,
+    incident_phi=0.0,
+    polarization_angle=0.0,
+)
+```
+
+## Test coverage
+
+Test coverage measures which lines of source code are executed
+during tests. Run it with:
+
+```bash
+source .venv/bin/activate
+pytest tests/ --cov=src/diffpes --cov-report=term-missing
+```
+
+To get as close to 100% as possible:
+
+1. **Simul and types** — Already well covered. Any new branch
+   (e.g. new polarization or dispatch level) should have a
+   corresponding test.
+2. **Expanded dispatch** — Test every `simulate_expanded(level=...)`
+   branch (novice, basic, basicplus, advanced, expert, soc) and
+   the unknown-level `ValueError`.
+3. **HDF5** — Round-trip all PyTree types; test error paths
+   (unknown type on load, missing group, unsupported type on save).
+4. **VASP file readers** (`read_doscar`, `read_eigenval`, `read_kpoints`,
+   `read_poscar`, `read_procar`) — Add tests that call each reader
+   on minimal in-repo fixture files (e.g. under `tests/fixtures/`)
+   so the parsing code paths are executed.
+5. **Plotting** — Exercise the public plotting API in tests (or
+   accept lower coverage for GUI-oriented code).
+6. **Edge branches** — Cover optional arguments (e.g.
+   `make_band_structure(..., kpoint_weights=...)`) and error
+   messages so one-off branches are hit.

diffpes-2026.3.1.dist-info/RECORD

@@ -0,0 +1,55 @@
+diffpes/__init__.py,sha256=dyrIAP5eT5itDHSrqHN5qgFjIWYIpCC0M0YHkRd8w50,1781
+diffpes/inout/__init__.py,sha256=eJ3ZXLESDUQWHsB_M0-yVzCRbeOdXASk52YUc_LICoE,2565
+diffpes/inout/chgcar.py,sha256=O3JXU0d-1YxHx86LPBYQAs8IVk0FmeDR0mv5bpD_cRI,15865
+diffpes/inout/doscar.py,sha256=ITcMVcNio2Y1XTsXSLBqwwyuUOv2oCAjEEZh63nMnFo,9685
+diffpes/inout/eigenval.py,sha256=kibxceLicm_5HlO0DduD21d2rIcJwzoIUZ1yFHlTLIE,9743
+diffpes/inout/hdf5.py,sha256=jbnNdW8C9m45MKfi4p5W9UWWdb6aEHieTUGePfuqxWw,24880
+diffpes/inout/helpers.py,sha256=Q8wHM2_bXXTRCJeO3rZ3FnhE7S5qkys_nFWbX8ILPpc,10250
+diffpes/inout/kpoints.py,sha256=x4PrTpjTLet7r9ZIT5DwS7KEFe0U23mCHpxMp3wSiPc,13944
+diffpes/inout/plotting.py,sha256=tLEHMqE6KJqWdSXXB6Cl2I4BoGQ5xIGMAMt099uYXI0,22759
+diffpes/inout/poscar.py,sha256=o6BUd0A3_V6jboES7jCGbkUtFLfWveKMasdueXMVh5s,6937
+diffpes/inout/procar.py,sha256=wH1_nMFFdE5384yhYTgKpZuDi8OVBrKQ9usZcbZgrKM,12203
+diffpes/inout/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffpes/maths/__init__.py,sha256=rrxgTCe7dT-Yk2prtuEN0qmDPvrzMEQVJYpSsRJFctc,2406
+diffpes/maths/dipole.py,sha256=wbmK7d65akLB-ibK6QEE6WT32PCstQDnomisaF-azKk,13039
+diffpes/maths/gaunt.py,sha256=T0xRsKwROpKIW2xfkcH8OpuZsxrFxYjKKxGyGsEJB00,16668
+diffpes/maths/spherical_harmonics.py,sha256=YJ3Lg3lLkHjPnMC2OLk0OLxgue9PCoycUWV2Eq96RSE,10282
+diffpes/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffpes/radial/__init__.py,sha256=GVo0oUbeivBXNCRwdK5-psQqi1uh8JoDjSBWzZoJzaw,1435
+diffpes/radial/bessel.py,sha256=3p0AvYVCg1mUM0-zeco2TZHMYxGGBJu3LHC35JxhmKI,6012
+diffpes/radial/integrate.py,sha256=SeSiUGpSD2zJRsChQYmgczgUzx84NqRr_NmGl8yKXu8,4250
+diffpes/radial/wavefunctions.py,sha256=tz3IVyD3wVw22G3NJOhn2HsoQ2_rN8_BkEqyB5T9i7I,10433
+diffpes/simul/__init__.py,sha256=oH1dK4_hlRHgACOgPxmWHJaD1Ao8DTZg8PaUxH52png,4653
+diffpes/simul/broadening.py,sha256=krkuYfnGtP3UrhCCJrSByvK7ECg19byekeU4STMNz5k,8881
+diffpes/simul/crosssections.py,sha256=Hg4ytjOjGu9KMgc0JtFUC8fPK-luiM2n8BW9jm2edBY,6831
+diffpes/simul/expanded.py,sha256=GiMzNht2zDmAePqVqg_mzMYx7eeiAyEPWtL2QSYTQzE,36000
+diffpes/simul/forward.py,sha256=ZzJu_8FVUfULSPvPTE6bnM1tjXxkHjjRA5s-zMlkNk4,22901
+diffpes/simul/oam.py,sha256=YUAZ4-ey69kOlsxYvCsogcyVv2CisKGki8z_qEBeOO0,3737
+diffpes/simul/polarization.py,sha256=aEgjdqxbtwldwc90YhKm15Kv8zAVlcMZDzF81nF1iqk,14614
+diffpes/simul/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffpes/simul/resolution.py,sha256=JPRNpCr0FZ7AOvgaU8Fk0LNrLuxTOcqhqT1NUiv70G8,4772
+diffpes/simul/self_energy.py,sha256=BlG138FqnRc1tgrswH7Opd-0GdexUq4as2Cyi99kfSs,5375
+diffpes/simul/spectrum.py,sha256=dH2P8Dts1oUfAV8F6O0q_KnMxM_WMH0QUEXVp0qRjqY,42380
+diffpes/simul/workflow.py,sha256=uTi6MXXJA46ZI1hJuDneUr9CrN0v_KR1a37jiJMuyKk,14132
+diffpes/tightb/__init__.py,sha256=kZwk-QAimOeT8eqeH3zQ0bkg6e31dsAY8q_0pcxy-EU,2261
+diffpes/tightb/diagonalize.py,sha256=NF6WOfybPm71QGd4Rza837id4lf9vrMoUdramRqXMBs,12420
+diffpes/tightb/hamiltonian.py,sha256=Hb-XzcdDuIbDBPZRATpqL_VT58VCr5ojO1H2_8CezDg,9679
+diffpes/tightb/projections.py,sha256=WMrWnI_XQm4lk5RgzG_Wo_g2uuG-7_2HS7joGQ3EgaY,4477
+diffpes/types/__init__.py,sha256=90jceGqMY3D9UtYATXN-OcQt4wjJn0dSM0gnkaoFdy8,4368
+diffpes/types/aliases.py,sha256=99JfYDr1P4xuEHvrBgvcwtl8hN5lHle1Hk_UUCdhxPA,1553
+diffpes/types/bands.py,sha256=kACWB0jaG5dAnB6mtBi-v3uCQL4Wo1YrgXUVM2JK4dI,40857
+diffpes/types/dos.py,sha256=MVPTPx9uIoYfVax5YwCtwlREmkk93PnicHns4S2dSiM,18763
+diffpes/types/geometry.py,sha256=kPrpRopD7OJzki4IAiel2hEpPcmm5jAQUW4NVQ8m3LM,11019
+diffpes/types/kpath.py,sha256=x6VgtKc-eYZm3kUJFjktLkJuXrQcuEbPpJYO1DfNB8g,13032
+diffpes/types/params.py,sha256=5xVFsD4rkvu70M5-vu2JpkjlUpkWlPNZM8RggOUCYuA,17712
+diffpes/types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffpes/types/radial_params.py,sha256=pdFanc7GLoi7BWuq-sxUxujgqcoVwZeiYfk7q9gHbY4,17874
+diffpes/types/self_energy.py,sha256=zucn_V9PYQSLd_ZEqjOA0RhBg7LWKkJkrh2Xm8R63YY,10287
+diffpes/types/tb_model.py,sha256=ZriOaGX2LnixXYzJLXC_EMOMpZ28E0EQ2pMZNjm0dNY,19706
+diffpes/types/volumetric.py,sha256=j9IMyY2PMkCqhXv4gI5PEEHYLbQrAdVSLNdwGrLKlPw,23506
+diffpes/utils/__init__.py,sha256=HJj0aTrTiaZYZQ8qXoGG2fE0O81CrHynz19XVzT3AC4,960
+diffpes/utils/math.py,sha256=SGC42JSZm4wKuDWBL-JLU__VOViAvP-5E8rODl1HZr8,8927
+diffpes/utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffpes-2026.3.1.dist-info/WHEEL,sha256=Uo4e6VmJM8J_cLBTtiWBRVQkc1yUEkw94xaL0B_lH6c,80
+diffpes-2026.3.1.dist-info/METADATA,sha256=B6KdLnSSMRB2cYghm-096eoTUHjaxkzD5PM_RPgzFog,7631
+diffpes-2026.3.1.dist-info/RECORD,,

diffpes-2026.3.1.dist-info/WHEEL

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