de-ebsd 0.2.0__py3-none-any.whl

de_ebsd/viz/views.py

@@ -0,0 +1,125 @@
+"""Host-neutral compositions of de_ebsd display objects.
+
+Scientific panels remain real :class:`anyplotlib.Figure` instances.  This
+module only groups figures with small JSON-compatible metadata so Jupyter and
+SpyDE can choose their own layout and lifecycle without nested HTML/iframes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cached_property
+from html import escape
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from de_ebsd.crystal.lattice import Crystal
+    from de_ebsd.sim.masterpattern import MasterPattern
+
+__all__ = ["PhaseOverview"]
+
+
+@dataclass
+class PhaseOverview:
+    """A phase's metadata and native anyplotlib panels.
+
+    ``figures`` is the integration boundary for application hosts. SpyDE can
+    register each value with its existing anyplotlib Electron bridge; Jupyter
+    displays this object directly through :meth:`_ipython_display_`.
+    """
+
+    crystal: Crystal
+    master_pattern: MasterPattern | None = None
+    name: str | None = None
+    texture_height: int = 128
+    n_grid: int = 96
+
+    def __post_init__(self) -> None:
+        if self.texture_height < 8:
+            raise ValueError("texture_height must be >= 8")
+        if self.n_grid < 8:
+            raise ValueError("n_grid must be >= 8")
+
+    @property
+    def metadata(self) -> dict[str, str | int | float | None]:
+        """Compact, JSON-compatible phase metadata for a sidebar/popover."""
+        return {
+            "name": self.name or _phase_name(self.crystal),
+            "space_group": self.crystal.space_group,
+            "space_group_symbol": str(self.crystal._spacegroup.short_name),
+            "a_nm": self.crystal.a,
+            "b_nm": self.crystal.b,
+            "c_nm": self.crystal.c,
+            "alpha_deg": self.crystal.alpha,
+            "beta_deg": self.crystal.beta,
+            "gamma_deg": self.crystal.gamma,
+            "volume_nm3": self.crystal.volume,
+            "density_g_cm3": self.crystal.density,
+            "atom_count": sum(self.crystal.multiplicities),
+            "simulation_backend": (
+                str(self.master_pattern.metadata.get("backend", "computed"))
+                if self.master_pattern is not None
+                else None
+            ),
+        }
+
+    @cached_property
+    def figure(self):
+        """The single native figure mounted by Jupyter or SpyDE."""
+        if self.master_pattern is None:
+            return self.crystal.show(title=f"{self.metadata['name']} structure")
+
+        from de_ebsd.viz.patterns import phase_overview_figure
+
+        texture = self.master_pattern.to_equirectangular(height=self.texture_height)
+        return phase_overview_figure(
+            self.crystal,
+            texture.detach().cpu().numpy(),
+            name=str(self.metadata["name"]),
+            n_grid=self.n_grid,
+        )
+
+    @property
+    def figures(self) -> dict[str, object]:
+        """Named native figures for notebook or application host mounting."""
+        return {"phase_overview": self.figure}
+
+    def _ipython_display_(self) -> None:
+        from IPython.display import HTML, display
+
+        display(HTML(_metadata_card(self.metadata)))
+        for figure in self.figures.values():
+            display(figure)
+
+    def __repr__(self) -> str:
+        metadata = self.metadata
+        return (
+            f"PhaseOverview(name={metadata['name']!r}, "
+            f"space_group={metadata['space_group']}, "
+            f"master_pattern={self.master_pattern is not None})"
+        )
+
+
+def _phase_name(crystal: Crystal) -> str:
+    elements = "+".join(dict.fromkeys(site.element for site in crystal.sites))
+    return elements or "phase"
+
+
+def _metadata_card(metadata: dict[str, str | int | float | None]) -> str:
+    name = escape(str(metadata["name"]))
+    symbol = escape(str(metadata["space_group_symbol"]))
+    backend = metadata["simulation_backend"] or "not computed"
+    cell = " × ".join(f"{float(metadata[key]):.4f}" for key in ("a_nm", "b_nm", "c_nm"))
+    return f"""
+    <div style="font:12px var(--jp-ui-font-family,system-ui,sans-serif);
+      color:var(--jp-ui-font-color1,#d8dee9);background:var(--jp-layout-color1,#20242d);
+      border:1px solid var(--jp-border-color2,#3b4252);border-radius:6px;
+      padding:8px 10px;max-width:940px;display:flex;gap:18px;align-items:baseline;flex-wrap:wrap">
+      <strong style="font-size:13px">{name}</strong>
+      <span>{symbol} ({int(metadata["space_group"])})</span>
+      <span>cell {cell} nm</span>
+      <span>{int(metadata["atom_count"])} atoms</span>
+      <span>ρ {float(metadata["density_g_cm3"]):.2f} g/cm³</span>
+      <span>{escape(str(backend))}</span>
+    </div>
+    """

de_ebsd/viz/widgets.py

@@ -0,0 +1,191 @@
+"""Portable experiment inspectors; one renderer for Jupyter, HTML, and SpyDE.
+
+HTML controls edit a local snapshot; notebook controls synchronize via traitlets.
+Scientific master-pattern and crystal views remain native anyplotlib figures.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from uuid import uuid4
+
+import anywidget
+import numpy as np
+import traitlets
+
+from de_ebsd.sim.detector import EBSDDetector
+from de_ebsd.sim.microscope import Microscope
+
+__all__ = ["DepthWidget", "MicroscopeWidget"]
+
+
+class _PortableWidget(anywidget.AnyWidget):
+    """Export the actual renderer without a notebook manager or CDN dependency."""
+
+    def _repr_html_(self):
+        identity = f"de-ebsd-{uuid4().hex}"
+        state = {
+            name: getattr(self, name)
+            for name in self.traits(sync=True)
+            if not name.startswith("_") and name != "layout"
+        }
+        payload = json.dumps(state, allow_nan=False).replace("<", "\\u003c")
+        renderer = str(self._esm).replace("</script", "<\\/script")
+        return f'''<div id="{identity}"></div><script type="module">
+{renderer}
+const state = {payload};
+const events = new Map();
+const model = {{
+  get: key => state[key],
+  set(key, value) {{
+    state[key] = value;
+    for (const callback of events.get(`change:${{key}}`) || []) callback();
+  }},
+  on(key, callback) {{
+    if (!events.has(key)) events.set(key, new Set());
+    events.get(key).add(callback);
+  }},
+  off(key, callback) {{ events.get(key)?.delete(callback); }},
+  save_changes() {{}},
+}};
+render({{model, el: document.getElementById("{identity}")}});
+</script>'''
+
+    def to_html(self):
+        """Interactive standalone HTML; edits do not run Python simulations."""
+        return (
+            '<!doctype html><html><head><meta charset="utf-8">'
+            '<meta name="viewport" content="width=device-width,initial-scale=1">'
+            "<title>de-ebsd experiment inspector</title></head><body>"
+            + self._repr_html_()
+            + "</body></html>"
+        )
+
+
+class MicroscopeWidget(_PortableWidget):
+    """Editable geometry with laboratory side view and detector-face inset.
+
+    Edits never mutate inputs or recompute existing master patterns. Read an
+    edited setup explicitly with to_microscope()/to_detector().
+    """
+
+    _esm = Path(__file__).with_name("setup_widget.js").read_text(encoding="utf-8")
+    energy_kev = traitlets.Float(20.0, min=0.001).tag(sync=True)
+    sample_tilt = traitlets.Float(70.0, min=0.0, max=90.0).tag(sync=True)
+    detector_tilt = traitlets.Float(0.0).tag(sync=True)
+    azimuthal = traitlets.Float(0.0).tag(sync=True)
+    twist = traitlets.Float(0.0).tag(sync=True)
+    probe_diameter_nm = traitlets.Float(0.0, min=0.0).tag(sync=True)
+    pcx = traitlets.Float(0.5).tag(sync=True)
+    pcy = traitlets.Float(0.5).tag(sync=True)
+    pcz = traitlets.Float(0.5, min=0.000001).tag(sync=True)
+    detector_rows = traitlets.Int(480, min=1).tag(sync=True)
+    detector_cols = traitlets.Int(480, min=1).tag(sync=True)
+    px_size = traitlets.Float(1.0, min=0.000001).tag(sync=True)
+    crystal_label = traitlets.Unicode("").tag(sync=True)
+    has_detector = traitlets.Bool(False).tag(sync=True)
+
+    @traitlets.validate(
+        "energy_kev",
+        "sample_tilt",
+        "detector_tilt",
+        "azimuthal",
+        "twist",
+        "probe_diameter_nm",
+        "pcx",
+        "pcy",
+        "pcz",
+        "px_size",
+    )
+    def _finite(self, proposal):
+        if not np.isfinite(proposal["value"]):
+            raise traitlets.TraitError("geometry values must be finite")
+        return proposal["value"]
+
+    @classmethod
+    def from_setup(cls, microscope=None, detector=None, crystal=None):
+        widget = cls()
+        if microscope is not None:
+            widget.energy_kev = microscope.energy_kev
+            widget.sample_tilt = microscope.sample_tilt
+            widget.azimuthal = microscope.azimuthal
+            widget.probe_diameter_nm = microscope.probe_diameter_nm or 0.0
+        if detector is not None:
+            widget.has_detector = True
+            widget.detector_rows, widget.detector_cols = detector.shape
+            widget.pcx, widget.pcy, widget.pcz = detector.pattern_center
+            widget.detector_tilt = detector.tilt
+            widget.twist = detector.twist
+            widget.px_size = detector.px_size
+            if microscope is not None and not np.allclose(
+                [microscope.sample_tilt, microscope.azimuthal],
+                [detector.sample_tilt, detector.azimuthal],
+            ):
+                raise ValueError("microscope and detector sample_tilt/azimuthal must agree")
+            widget.sample_tilt = detector.sample_tilt
+            widget.azimuthal = detector.azimuthal
+        if crystal is not None:
+            widget.crystal_label = _phase_name(crystal)
+        return widget
+
+    def to_microscope(self):
+        return Microscope(
+            energy=self.energy_kev * 1e3,
+            sample_tilt=self.sample_tilt,
+            azimuthal=self.azimuthal,
+            probe_diameter_nm=self.probe_diameter_nm or None,
+        )
+
+    def to_detector(self):
+        return EBSDDetector(
+            shape=(self.detector_rows, self.detector_cols),
+            pattern_center=(self.pcx, self.pcy, self.pcz),
+            sample_tilt=self.sample_tilt,
+            tilt=self.detector_tilt,
+            azimuthal=self.azimuthal,
+            twist=self.twist,
+            px_size=self.px_size,
+        )
+
+
+class DepthWidget(_PortableWidget):
+    """Read-only depth model, with local energy and slice selection."""
+
+    _esm = Path(__file__).with_name("depth_widget.js").read_text(encoding="utf-8")
+    energies_kev = traitlets.List().tag(sync=True)
+    profiles = traitlets.List().tag(sync=True)
+    integration_bins = traitlets.List().tag(sync=True)
+    depth_step = traitlets.Float(1.0).tag(sync=True)
+    energy_index = traitlets.Int(0, min=0).tag(sync=True)
+    slice_index = traitlets.Int(0, min=0).tag(sync=True)
+
+    @classmethod
+    def from_distribution(cls, depth, energy_kev=None):
+        counts = np.asarray(depth.accum_z, dtype=float)
+        energies = np.asarray(depth.energies_kev, dtype=float)
+        if (
+            counts.ndim != 4
+            or 0 in counts.shape
+            or len(energies) != counts.shape[0]
+            or not np.isfinite(counts).all()
+            or (counts < 0).any()
+            or not np.isfinite(energies).all()
+            or not np.isfinite(depth.depth_step)
+            or depth.depth_step <= 0
+            or not np.isfinite(depth.n_total)
+            or depth.n_total <= 0
+        ):
+            raise ValueError("depth display requires finite nonnegative counts and positive scales")
+        index = depth.n_energies - 1 if energy_kev is None else depth.energy_index(energy_kev)
+        return cls(
+            energies_kev=energies.tolist(),
+            profiles=(counts.sum(axis=(2, 3)) / depth.n_total).tolist(),
+            integration_bins=depth.integration_depths().tolist(),
+            depth_step=depth.depth_step,
+            energy_index=index,
+        )
+
+
+def _phase_name(crystal):
+    return "+".join(dict.fromkeys(site.element for site in crystal.sites)) or "phase"

de_ebsd-0.2.0.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: de-ebsd
+Version: 0.2.0
+Summary: Differentiable, GPU-accelerated EBSD: dynamical master-pattern simulation, Monte Carlo transport, indexing, refinement and HR-EBSD, in PyTorch
+Author-email: Carter Francis <cartsfrancis@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/directelectron/de-ebsd
+Project-URL: Source, https://github.com/directelectron/de-ebsd
+Project-URL: Issues, https://github.com/directelectron/de-ebsd/issues
+Project-URL: Changelog, https://github.com/directelectron/de-ebsd/blob/main/CHANGELOG.rst
+Project-URL: Documentation, https://directelectron.github.io/de-ebsd/
+Keywords: EBSD,dynamical-diffraction,Bloch-wave,master-pattern,pytorch,kikuchipy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy
+Requires-Dist: torch>=2.4
+Requires-Dist: orix
+Requires-Dist: diffsims
+Requires-Dist: h5py
+Requires-Dist: anyplotlib
+Requires-Dist: anywidget
+Provides-Extra: validate
+Requires-Dist: kikuchipy; extra == "validate"
+Provides-Extra: live
+Requires-Dist: cupy-cuda12x; extra == "live"
+Dynamic: license-file
+
+# de-ebsd
+
+Differentiable, GPU-accelerated EBSD in PyTorch: dynamical master-pattern
+simulation from a crystal structure, native Monte Carlo electron transport,
+orientation indexing (dictionary, spherical-harmonic and live), gradient and
+high-resolution refinement, pattern-center calibration and HR-EBSD strain. The
+API is composable and object oriented, in the manner of
+[abTEM](https://github.com/abTEM/abTEM), and every intermediate stage is
+inspectable.
+
+A master pattern is the backscattered-electron intensity as a function of
+crystal direction, stored on the square-Lambert grid. de-ebsd builds it from
+first principles -- crystal, structure factors with absorption, reflections,
+Bloch-wave dynamical solve, depth integration over a Monte Carlo exit-depth
+profile -- and then runs the inverse problem against measured patterns. The
+physics is ported from [EMsoft](https://github.com/EMsoft-org/EMsoftOO)
+(Callahan & De Graef 2013), which remains the validation oracle (de-ebsd does
+not call EMsoft at runtime); see [NOTICE](NOTICE). Indexing follows EMSphInx
+(Lenthe, Singh & De Graef 2019) and emits [orix](https://github.com/pyxem/orix)
+objects, so [kikuchipy](https://github.com/pyxem/kikuchipy) and other tools can
+use it as a backend.
+
+## Installation
+
+Windows / Linux with uv (Python >= 3.11; torch comes from the CUDA 12.4
+index on Windows and the CPU index on Linux, configured in `pyproject.toml`):
+
+```
+git clone https://github.com/directelectron/de-ebsd
+cd de-ebsd
+uv sync
+```
+
+The distribution is named `de-ebsd`; the Python package is `de_ebsd`. The
+fused CUDA kernels of live indexing need CuPy: `uv sync --extra live`.
+
+## Quickstart: simulation
+
+```python
+import de_ebsd as de
+
+crystal = de.Crystal.from_parameters(
+    a=0.5431, space_group=227, atoms=[("Si", (0.125, 0.125, 0.125))]
+)
+microscope = de.Microscope(energy=20e3, sample_tilt=70.0)
+sim = de.MasterPatternSimulator(
+    crystal,
+    microscope,
+    npx=500,
+    dmin=0.05,
+    bethe=de.BetheParameters(),
+    # backend="bloch_prism" is the default: the batched dynamical solve.
+    # "bloch" is the one-direction-at-a-time float64 reference it reproduces.
+)
+
+# every stage is inspectable (all figures render through anyplotlib):
+sim.structure_factors().show()  # |U_g| per family, absences, V_0
+sim.reflections(k=(0, 0, 1)).show()  # Bethe strong / weak split for one beam
+sim.dynamical_matrix(k=(0, 0, 1)).show()
+
+master = sim.compute(device="cuda")  # -> MasterPattern
+master.show(projection="lambert")  # also "stereographic" and "sphere"
+sim.crystal.show()  # real 3-D expanded crystal structure
+
+# refine and recompute (structure factors are reused when still valid):
+better = sim.refine(npx=1000, dmin=0.04)
+
+# project to a detector for a batch of orientations (orix Rotation):
+detector = de.EBSDDetector(shape=(480, 480), pattern_center=(0.5, 0.5, 0.6))
+patterns = master.project(detector, orientation=rotations)
+
+# interactive geometry widget in Jupyter (anywidget):
+sim.show_setup(detector=detector)
+
+# phase composition for Jupyter or a host application; figures stay native:
+phase = sim.crystal.overview(master_pattern=master)
+sim.microscope.show(detector=detector, crystal=sim.crystal)
+
+# STEM zone-axis exploration: geometric Kikuchi lines + kinematic spots,
+# independently toggleable in one projection; no master pattern required:
+explorer = sim.crystal.explore(energy_kev=200, dmin=0.1)
+```
+
+The exit-depth statistics the dynamical solve integrates over come from a native
+Monte Carlo (`de_ebsd.sim.montecarlo`) unless you pass a `DepthDistribution`,
+for example one read from an EMsoft Monte Carlo file.
+
+## Quickstart: indexing
+
+```python
+from de_ebsd.index import (
+    DictionaryIndexer,
+    SphericalIndexer,
+    refine_orientation,
+    remove_background,
+)
+
+patterns = remove_background(raw, static_bg=static_bg, operation="divide")
+
+# Spherical indexing: one SO(3) cross-correlation per pattern, on the GPU.
+indexer = SphericalIndexer(master, detector, bandwidth=68, device="cuda")
+rotations, quality = indexer.index(patterns)
+
+# Dictionary indexing over a fundamental-zone sample, as an orix CrystalMap:
+xmap = DictionaryIndexer(master, detector, resolution=2.5).index_scan(scan, step=0.5)
+
+# Sharpen a coarse index by gradient or Levenberg-Marquardt refinement:
+refined, score = refine_orientation(patterns, master, detector, rotations, method="lm")
+```
+
+Also in `de_ebsd.index`: `refine_hr` (band-edge refinement of orientation and,
+optionally, pattern center), `determine_pattern_center` (one center shared by
+many patterns), `hrebsd` (lattice strain and rotation by cross-correlation
+against a reference pattern) and `LiveIndexer`, which indexes, refines and
+strain-fits a camera's frames where they already are on the GPU, at thousands of
+patterns a second.
+
+## Examples
+
+The [examples folder](examples/) contains executable Sphinx-Gallery tutorials,
+grouped by the layer they exercise.
+
+**[Master-pattern simulation](examples/simulation/)** -- the forward chain:
+
+- [CIF to detector](examples/simulation/cif_to_detector.py): silicon structure,
+  native Monte Carlo, diffraction intermediates, full 3D master pattern,
+  orix orientations, detector images, phase overview, and HDF5 round trip.
+- [Energy-resolved simulation](examples/simulation/energy_resolved_simulation.py):
+  nickel transport statistics and dynamical patterns at multiple energies.
+- [Resolution and backends](examples/simulation/resolution_and_backends.py):
+  grid refinement, detector-space differences, and PRISM/Bloch comparison,
+  plus the microscope, probe, detector and depth-slice inspectors.
+- [Compare with EMsoft](examples/simulation/compare_emsoft.py): use the bundled
+  nickel reference's crystal, Bethe settings and Monte Carlo profile, then
+  compare both hemispheres, normalized residuals, and detector patterns.
+- [STEM orientation explorer](examples/simulation/stem_orientation_explorer.py):
+  a band-line sphere, crystal structure, and a combined lines/spots view. It
+  provides geometric band centerlines and relative elastic kinematic spot
+  intensities; it does not simulate transmission Kikuchi contrast or
+  convergent-beam discs.
+
+**[Orientation indexing](examples/indexing/)** -- the inverse problem, each on a
+synthetic two-grain scan with known orientations:
+
+- [Dictionary indexing](examples/indexing/dictionary_indexing.py): background
+  removal, a fundamental-zone template library, a `CrystalMap` with IPF and
+  quality maps, and Levenberg-Marquardt refinement to sub-degree accuracy.
+- [Spherical indexing](examples/indexing/spherical_indexing.py): the SO(3)
+  cross-correlation surface, the bandwidth accuracy/cost trade-off and how it
+  fails when truncated too far, then refinement off the peak.
+
+Run scripts with `uv run python examples/simulation/cif_to_detector.py`. They
+use small CPU-friendly teaching settings; see
+[examples/README.rst](examples/README.rst) for execution, display, and
+convergence notes.
+
+## Documentation
+
+The full site -- user guide, design notes, the executable example gallery, and
+an API reference generated from the docstrings -- is published at
+<https://directelectron.github.io/de-ebsd/>. To build it locally:
+
+```shell
+uv sync --group docs
+uv run python -m sphinx -b html -W --keep-going docs docs/_build/html
+```
+
+Open `docs/_build/html/index.html`. The build executes every example, so a
+broken example fails the build.
+
+Start at [`docs/user/conventions.rst`](docs/user/conventions.rst) before
+interpreting any number: units, the Cartesian crystal frame, square-Lambert
+storage, the orientation convention and the space-group origin choice are all
+load-bearing, and they are what make de-ebsd's output comparable to EMsoft's
+and kikuchipy's. The design notes under [`docs/dev/`](docs/dev/) cover the
+architecture, the dynamical algorithm, the Monte Carlo, the indexers and the
+validation numbers.
+
+## Validation
+
+EMsoft is the oracle (validation only). The script compares a simulated master
+pattern with EMsoft references by per-pixel Pearson correlation of the Lambert
+maps -- scale invariant, so normalization differences do not matter:
+
+```
+uv run python scripts/validate_master_pattern.py --material ni
+uv run python scripts/validate_master_pattern.py --material si \
+    --mc /path/to/Si_MC.h5 --device cuda
+```
+
+Ni uses kikuchipy's bundled master pattern and runs with no external files. Si
+needs a local EMsoft `Si_MC.h5` reference run (not redistributed here) -- point
+`--mc` or `DE_EBSD_SI_MC` at your copy.
+
+**Si r = 1.0000** at native npx-500 against `Si_MC.h5`, and **Ni r = 1.00000**
+against a matched-settings EMsoft master; cubic and tetragonal phases, single-
+and multi-component, agree to that precision. The npx-500 Si master (about two
+million directions) computes in about 10 s (fp32) on a Pascal TITAN X, roughly
+10 times faster than EMsoft on a 24-thread CPU for a full energy-resolved
+master. Monoclinic settings and one hexagonal intensity residual are the open
+items; see the validation page of the design notes.
+
+## Development
+
+```
+uv run pytest
+uv run ruff check
+uv run ruff format --check
+```
+
+## License
+
+GPL-3.0-or-later. See [LICENSE](LICENSE) and [NOTICE](NOTICE) for the work this
+package is built on.

de_ebsd-0.2.0.dist-info/RECORD

@@ -0,0 +1,69 @@
+de_ebsd/__init__.py,sha256=2R1Wzpzn46bZkEd0Citsyfs40HSvCyBozP0zF588Y5U,2113
+de_ebsd/core/__init__.py,sha256=S50uL6VEj-vhj2EWnMbc9khHwCTGplXZb7BkbXgzpnQ,750
+de_ebsd/core/constants.py,sha256=Myd3_n3r7pxZa9wOrUh8VSy4vrfHp1y_UOZP-ClIqQw,3202
+de_ebsd/core/device.py,sha256=KhrkdALz7lZhoKx4ARU3_tazsUUusBFcijFK3coY7Pw,360
+de_ebsd/core/geometry.py,sha256=UetwFkMSJ2GS1tOefIqRpqwJ8atw8IwQuJoGtg7Grlg,2617
+de_ebsd/core/lambert.py,sha256=Snhu7CpUfIzoq7BrEBEEeOeqklV9Urn51q3qCn_8IYQ,5636
+de_ebsd/core/rotation.py,sha256=FoQKm4eXi2zeqBviIHrjCpeBIcyx_IvHJ6AQq2hHTLc,5238
+de_ebsd/crystal/__init__.py,sha256=r526mVbO-DXp43Q2RYs0KvL1NR_YS_L6M7sesvdprGc,669
+de_ebsd/crystal/lattice.py,sha256=JNsRitSHxi_l3TxytWutV_MMTltZu5zYM6pTHiNlxyE,18538
+de_ebsd/crystal/scattering.py,sha256=BiawEYuBtMhX4gsupVV2aAA4cqX3ZE0AuHZpEsZ8FJI,11194
+de_ebsd/crystal/scattering_torch.py,sha256=GQU95u6Lk6rpRg0Y12ANKkzM7b5AFBXw8p-uR5BIY2k,8965
+de_ebsd/crystal/structure_factors.py,sha256=wiYRgUbSStwlse9ZWl_LZapEQhpgdvX1k14c1ooriKU,11015
+de_ebsd/crystal/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+de_ebsd/crystal/data/element_properties.py,sha256=wApsi2JKzs8T3ET6wOG84U3FbMN27xvBYieYKAcEJFk,1860
+de_ebsd/crystal/data/scattering_tables.py,sha256=iX2wli6NgeRVDWn1z_u2AeRrnP-VUVylCyPqpn_G5-Q,16357
+de_ebsd/diffraction/__init__.py,sha256=Gjid94oeawbvq2pWE71VKmjnIKZmhcjzwPSQeScLxRk,1177
+de_ebsd/diffraction/backends.py,sha256=ze16Dcq4HwrBTxlptPWch9B468oYrVWxZPErVCi7nGU,12144
+de_ebsd/diffraction/bethe.py,sha256=RdYUWS9i1UG--kcu8_Y_UfkLUzJNmRYUGjfzXAOb28g,839
+de_ebsd/diffraction/kinematic.py,sha256=hXA2hp4pxc3kO8hIop7o7DS4AAd0xtR8zsng4WI1pmY,17298
+de_ebsd/diffraction/kvectors.py,sha256=Ic1XJgQs03rjM5GOhSfJYiqPbBVQpcD4f1clfdVULew,4886
+de_ebsd/diffraction/prism.py,sha256=7Src9NPts6LtvUJb61izM4GVWUdsR7hU8J4l_ISc0xI,9890
+de_ebsd/diffraction/reflections.py,sha256=pJh9ktSUqSmX9Tpbe70L6V3Rlwd3sV09M-E567e6n8A,8130
+de_ebsd/index/__init__.py,sha256=jDj4Q_IxWduESve0eW1kRdNJHGk8BE1I_dm-GX12h2c,2023
+de_ebsd/index/_kernels.py,sha256=jrsk-7Ael9YHCP_wzRGLFh1Ads6nz8WtcHKqD5nrzGA,8233
+de_ebsd/index/backproject.py,sha256=2LB-W3RLXAKzXHMt6gNJXq4Ih6pqbPsqXixNHkgK6x4,7341
+de_ebsd/index/crosscorr.py,sha256=QQlk37BCHTwP6jenQuLgBlbCIP0g9UU1j2SSnaeYtrc,28059
+de_ebsd/index/dictionary.py,sha256=raj8Q-MF8ptlBzICdJnkQSK727OP1infc1qA5f-uRLc,15251
+de_ebsd/index/io.py,sha256=xEPzhfnkAhPWytQ38Hn16Y1vsE30Eb5JYUhlZ42TM24,12361
+de_ebsd/index/preprocess.py,sha256=1E7aPbWgACjbFoZakZiyGZ2NcemRwSZSI596_E59SPU,6672
+de_ebsd/index/live/__init__.py,sha256=NIN0GkG0-jglfOMNXqeCdaYwFVJjM3erw5RV2IQWcfE,126
+de_ebsd/index/live/background.py,sha256=Igs0IyUhGnhIulwRqIcskYUbmWOuPWiUwHLpvyWIcjc,4697
+de_ebsd/index/live/calibration.py,sha256=--AOwvfADAmqpIIx8NwS4Oo4_Qjp9CjviBHInej99wg,3130
+de_ebsd/index/live/common.py,sha256=58lkc7z4EIeNDeS9SWHsEx_oFZNDFxM1yZxmuQgxvmo,2036
+de_ebsd/index/live/deformation.py,sha256=lervj_iY9E4CZzwOqU2R1CHmh3Wyzva_NWOQ1j-V0dQ,14066
+de_ebsd/index/live/indexer.py,sha256=Nne84trTGP6EO4lb970eNwpxEK84PMpUI0dxMlR5l-k,19076
+de_ebsd/index/refine/__init__.py,sha256=V9UESmUAp1IJkAx-fPOsKHQuw3pLdw06dt-90n_yAfk,325
+de_ebsd/index/refine/highres.py,sha256=oilFaN-ej7KWFOLogOTrFyNJlE-FL6AtetPnAHIjI14,20564
+de_ebsd/index/refine/levenberg.py,sha256=sL3-sfkNirj0xd25XRnmk_wsJsVFdiMxuPKKlZ8HhuU,1044
+de_ebsd/index/refine/orientation.py,sha256=hFwxrenVd90z0ShlF2c0jj9oz8sm67qs2L16H2ro-GQ,15363
+de_ebsd/index/refine/pattern_center.py,sha256=jfBAIImjmHcepFbGBHoWcyKN7ymhcJyTovImJllWpU0,14845
+de_ebsd/index/spherical/__init__.py,sha256=3-Abio7NeLOeQr8Xh3S7Z5P517muh4EoR42LgCIQFm0,958
+de_ebsd/index/spherical/correlation.py,sha256=V0L5aDCQYs_XL4egOwiN_7zC4ODw76fLa42m8Yt4KcU,4821
+de_ebsd/index/spherical/harmonics.py,sha256=9beJ7MBvxL9z5hsqWWn1RLKcM1-1_RzfYCo-ZPkczrA,13072
+de_ebsd/index/spherical/indexer.py,sha256=QrjQsve7dFd-Xtc4nXK7H-tnJEO22BULeLUguFCZxaw,14787
+de_ebsd/index/spherical/wigner.py,sha256=tl60rzeUQ4hD1sl51730ShbpdkNS4mSXuaJOC5GW5SQ,7115
+de_ebsd/sim/__init__.py,sha256=NpQpmclRQHzyOX3VmClgIOPzbQpARd6LVCOw6a6m6ps,642
+de_ebsd/sim/detector.py,sha256=lBp1H48gd-7hK-p-ME4EGWIW1Dx-L1RxhZjA-C4g3cw,5059
+de_ebsd/sim/masterpattern.py,sha256=3b8PgONOeMIVUZNjfIdNWdkcVwaSnnX7mfY1mMONgdE,9285
+de_ebsd/sim/microscope.py,sha256=XaxP87N4APKYreWIuDWdtA7r6ofI85QGypm5xRg0KpY,3149
+de_ebsd/sim/simulator.py,sha256=A5sTfj8i5MS-7O2vq0yG7UysLJsVgZchoz4Ie3XvaKU,12025
+de_ebsd/sim/montecarlo/__init__.py,sha256=1kNvxm5VOEvSAxq7UB9Vc6WDwIx7GhkXwMdQvSVaAUY,499
+de_ebsd/sim/montecarlo/depth.py,sha256=YTVM3IT4a15E_zUJeH9ccr3vwOx8_SXzJPx8wUx_Rtk,6658
+de_ebsd/sim/montecarlo/transport.py,sha256=1yniQ-JBfL7nZ3Gc2HxHEW0gPapX2chDGVm-xbwab4U,20694
+de_ebsd/viz/__init__.py,sha256=_9r_z04l-0RVVDA2WjbWfpu2twArVqoXceyXTBv100c,1442
+de_ebsd/viz/camera.py,sha256=AnLOjq46hcoERF7zifg5reYXkc2LQJZv3ssya9jY-vw,2186
+de_ebsd/viz/depth_widget.js,sha256=FSFxwQtCgmJT8ebvy6hXwLnzwocUuaNKoah7gm5sE30,5925
+de_ebsd/viz/explorer.py,sha256=KkSfnCddA6u2LwbcW4TygaqUvlTuVaBZRwnNtkMQ2p4,26115
+de_ebsd/viz/figures.py,sha256=S9kT7gL7IpU4_WIEXrn2ZcSxRdn_14WPARf4AXacEFA,2388
+de_ebsd/viz/maps.py,sha256=ARbngihHbDbhshI50krCw3fT3xtBL4mnVdbHfzUSLS0,10514
+de_ebsd/viz/patterns.py,sha256=mRKKZ5eUrsCLwP7_Ar6NsPcIZJ5RaILF9NtDLI8U7sA,5788
+de_ebsd/viz/setup_widget.js,sha256=mdaJplaYLfDLTfPyLcZi-biwfidp0Jb-iuVPLt3Wau4,12141
+de_ebsd/viz/views.py,sha256=SdIDocKWOTqgb4CZkMogjQk9k9o7auKqBI2xKC-EMnU,4684
+de_ebsd/viz/widgets.py,sha256=yWqAsHZOGXIS4HjfxR2oGqjwvuXiLltwL8pfzp8lfNg,7228
+de_ebsd-0.2.0.dist-info/licenses/LICENSE,sha256=v1Fr86wVTKRvW6ogT1m8daMI2FbBTYfy8F1AeVOlk9o,35155
+de_ebsd-0.2.0.dist-info/licenses/NOTICE,sha256=0cW-1S8ZVedeYdAa-iVV-WqKkza5F203vhFbesGUXkI,2338
+de_ebsd-0.2.0.dist-info/METADATA,sha256=JtkRrzLtOP66d_0idje7Y8iZ-OsUFlpElYjR277s3Tc,10750
+de_ebsd-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+de_ebsd-0.2.0.dist-info/top_level.txt,sha256=qsZnl1OBHXFetZDzxHVYURMzNGwfuEjo-KBRbmngz2I,8
+de_ebsd-0.2.0.dist-info/RECORD,,

de_ebsd-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+