### Enable On-Demand Dependency Installation

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Enables automatic installation of optional dependencies (e.g., jax) using uv/pip when a module requiring them is first imported. This is useful for managing dependencies and ensuring a minimal installation.

```bash
export RGPYCRUMBS_AUTO_DEPS=1
python -c "from rgpycrumbs.surfaces import FastTPS"  # jax installed automatically
```

--------------------------------

### Install rgpycrumbs Core

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Installs the core rgpycrumbs package. Optional dependencies like jax, scipy, and ase are resolved on demand when first used, provided uv is on PATH and auto-resolution is enabled.

```bash
pip install rgpycrumbs
```

--------------------------------

### Install rgpycrumbs with Pip Extras

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Installs rgpycrumbs with pre-installed optional dependencies for specific functionalities. Options include 'surfaces' (JAX), 'interpolation' (SciPy), 'analysis' (ASE + SciPy), or 'all' for everything pip-installable.

```bash
# Surface fitting (JAX)
pip install rgpycrumbs[surfaces]

# Spline interpolation (SciPy)
pip install rgpycrumbs[interpolation]

# Structure analysis (ASE + SciPy)
pip install rgpycrumbs[analysis]

# Everything pip-installable at once
pip install rgpycrumbs[all]
```

--------------------------------

### Install rgpycrumbs Full Stack with Pixi

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Installs the complete rgpycrumbs stack, including conda-only dependencies like tblite, ira_mod, and ovito, using the pixi package manager. This ensures all functionalities are available.

```bash
pixi install
```

--------------------------------

### Development Environment Setup and Testing with uv

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

Commands to initialize the development environment using uv and execute specific test suites. It includes options for running pure tests and tests requiring optional dependencies like scipy.

```bash
# Clone and install in development mode with test dependencies
uv sync --extra test

# Run the pure tests (no heavy optional deps)
uv run pytest -m pure

# Run interpolation tests (needs scipy)
uv run --extra interpolation pytest -m interpolation
```

--------------------------------

### Split Trajectory Files with CLI

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Splits a multi-image .con trajectory file into individual frames using the rgpycrumbs CLI. This is useful for initializing new NEB calculations, for example, with ASE.

```bash
# Split a multi-image .con trajectory into individual frames
rgpycrumbs eon con-splitter neb_final_path.con -o initial_images
```

--------------------------------

### List Available CLI Commands

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Displays the available commands for the rgpycrumbs CLI. The CLI uses a PEP 723 dispatcher for running scripts in isolated uv environments.

```bash
rgpycrumbs --help
```

--------------------------------

### Using eOn NEB Path Plotting Tool

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

Examples for using the plt-neb script to visualize energy profiles from NEB calculations. It supports saving to files or interactive display.

```bash
# View help for the specific script
python -m rgpycrumbs eon plt-neb --help

# Plot a specific range and save to PDF
python -m rgpycrumbs eon plt-neb --start 100 --end 150 -o final_path.pdf

# Show plot interactively
python -m rgpycrumbs eon plt-neb --start 280
```

--------------------------------

### Plotting NEB Paths Interactively (Shell)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Runs the 'plt-neb' script to display NEB energy profiles interactively without saving to a file, starting from a specified index.

```shell
python -m rgpycrumbs eon plt-neb --start 280
```

--------------------------------

### Use rgpycrumbs Data Types

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Demonstrates the usage of lightweight data containers from rgpycrumbs.basetypes for NEB paths and saddle search results. It shows how to store NEB path snapshots and track saddle search outcomes.

```python
from rgpycrumbs.basetypes import nebpath, SaddleMeasure

# Store a NEB path snapshot
path = nebpath(
    norm_dist=[0.0, 0.25, 0.5, 0.75, 1.0],
    arc_dist=[0.0, 1.2, 2.4, 3.6, 4.8],
    energy=[0.0, -0.5, 0.3, -0.2, 0.0],
)

# Track saddle search results
result = SaddleMeasure(
    pes_calls=142,
    success=True,
    barrier=0.35,
    method="gprdimer",
)
```

--------------------------------

### Getting Help for plt-neb Script (Shell)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Retrieves the help text for the 'plt-neb' script within the 'eon' subcommand group. This script is used for plotting NEB energy paths.

```shell
$ python -m rgpycrumbs eon plt-neb --help
--> Dispatching to: uv run /path/to/rgpycrumbs/eon/plt_neb.py --help
Usage: plt_neb.py [OPTIONS]

  Plots a series of NEB energy paths from .dat files.
...
Options:
  --input-pattern TEXT      Glob pattern for input data files.
  -o, --output-file PATH    Output file name.
  --start INTEGER           Starting file index to plot (inclusive).
  --end INTEGER             Ending file index to plot (exclusive).
  --help                    Show this message and exit.
```

--------------------------------

### Perform Spline Interpolation with rgpycrumbs

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Shows how to use rgpycrumbs.interpolation.spline_interp for 1D energy profile interpolation. It takes a coarse energy profile along a reaction coordinate and interpolates it to a finer resolution.

```python
import numpy as np
from rgpycrumbs.interpolation import spline_interp

# Coarse energy profile along a reaction coordinate
rc = np.linspace(0, 1, 10)
energy = np.array([0.0, -0.3, -0.8, -1.0, -0.5, 0.2, 0.8, 0.5, -0.1, 0.0])

# Interpolate to 200 points
rc_fine, energy_fine = spline_interp(rc, energy, num=200)
```

--------------------------------

### Plot NEB Energy Profiles with CLI

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Plots NEB energy profiles from eOn .dat files using the rgpycrumbs CLI. It allows specifying a range of iterations for the plot and saving it to a PDF file, or interactively plotting the latest iterations.

```bash
# Plot NEB energy profiles from eOn .dat files (iterations 100-150)
rgpycrumbs eon plt-neb --start 100 --end 150 -o neb_profile.pdf

# Interactive plot of the latest iterations
rgpycrumbs eon plt-neb --start 280
```

--------------------------------

### Fit Surface Model with rgpycrumbs

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/quickstart.org

Demonstrates fitting a thin-plate spline surface model using rgpycrumbs.surfaces.get_surface_model. It generates sample 2D data, fits the model, predicts values on a grid, and calculates posterior variance.

```python
import numpy as np
from rgpycrumbs.surfaces import get_surface_model

# Generate sample 2D data
rng = np.random.default_rng(42)
x_train = rng.uniform(-2, 2, size=(30, 2))
y_train = np.sin(x_train[:, 0]) * np.cos(x_train[:, 1])

# Fit a thin-plate spline surface
TPS = get_surface_model("tps")
model = TPS(x_train, y_train)

# Predict on a grid
x_grid = np.mgrid[-2:2:50j, -2:2:50j].reshape(2, -1).T
y_pred = model(x_grid)

# Posterior variance (uncertainty estimate)
y_var = model.predict_var(x_grid)
```

--------------------------------

### Importing rgpycrumbs Library Modules

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

Demonstrates how to import various modules from the rgpycrumbs library. Dependencies are resolved automatically when RGPYCRUMBS_AUTO_DEPS=1 is set or via explicit installation of optional extras.

```python
# Surface fitting (requires jax: pip install rgpycrumbs[surfaces])
from rgpycrumbs.surfaces import get_surface_model
model = get_surface_model("tps")

# Structure analysis (requires ase, scipy: pip install rgpycrumbs[analysis])
from rgpycrumbs.geom.analysis import analyze_structure

# Spline interpolation (requires scipy: pip install rgpycrumbs[interpolation])
from rgpycrumbs.interpolation import spline_interp

# Data types (no extra deps)
from rgpycrumbs.basetypes import nebpath, SaddleMeasure
```

--------------------------------

### Dependency Mapping for Dynamic Resolution

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/devnotes.org

This Python dictionary, `_DEPENDENCY_MAP`, located in `rgpycrumbs/_aux.py`, maps importable module names to their corresponding pip install specifications and optional extras. This is crucial for the dynamic dependency resolution mechanism, allowing the system to determine which packages to install on demand.

```python
_DEPENDENCY_MAP = {
    "jax":              ("jax>=0.4",    "surfaces"),
    "scipy":            ("scipy>=1.11", "interpolation"),
    "ase":              ("ase>=3.22",   "analysis"),
}
```

--------------------------------

### Execute rgpycrumbs with Development Flags

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

Demonstrates how to run scripts using standard isolated execution versus development mode, which respects local editable installs.

```shell
# Standard execution (Isolated: uv resolves dependencies from scratch)
rgpycrumbs mygroup myscript

# Development execution (Active Env: uses sys.executable, respects editable installs)
rgpycrumbs --dev mygroup myscript
```

--------------------------------

### Robust Structure Alignment Example (Python)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/geom/alignment.org

Demonstrates how to use the align_structure_robust function to align two atomic structures, handling potential index scrambling. It utilizes the IRA algorithm if available and configured, otherwise falls back to standard methods. Requires the 'ase' library.

```python
from ase.build import molecule
from rgpycrumbs.geom.api.alignment import align_structure_robust, IRAConfig

# 1. Create a reference and a scrambled mobile structure
ref = molecule("H2O")
mobile = ref.copy()
mobile.rotate(90, 'z')
# Scramble indices: Swap H1 and H2
mobile = mobile[[0, 2, 1]]

# 2. Configure Alignment
config = IRAConfig(enabled=True, kmax=1.8)

# 3. Align
# 'mobile' is modified in-place to match 'ref'
result = align_structure_robust(ref, mobile, config)

print(f"Method used: {result.method}")
```

--------------------------------

### Detect Fragments Geometrically (Python)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/geom/detect_fragments.org

Programmatically detect molecular fragments using the geometric method within Python scripts. This example demonstrates constructing a water dimer using ASE and then applying the `find_fragments_geometric` function to verify its separation into two fragments based on covalent bond checks and atomic radii.

```python
from ase import Atoms
from ase.build import molecule
from rgpycrumbs.geom.detect_fragments import find_fragments_geometric

# 1. Construct a water dimer
# One water at the origin, another separated by 3.5 Angstroms
water_a = molecule("H2O")
water_b = molecule("H2O")
water_b.translate([3.5, 0, 0])

dimer = water_a + water_b

# 2. Detect fragments using geometric criteria (Cordero radii)
# A standard covalent bond check would treat these as separate.
n_frags, labels = find_fragments_geometric(dimer, bond_multiplier=1.2)

print(f"System contains {n_frags} fragments.")
print(f"Atom labels: {labels}")
```

--------------------------------

### Release Process: Building Changelog (Bash)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Steps involved in the release process, specifically building the changelog using 'towncrier' based on fragments in the 'docs/newsfragments/' directory.

```bash
# 1. Ensure tests pass
uv run --extra test pytest -m pure

# 2. Build changelog (uses towncrier fragments in docs/newsfragments/)
uvx towncrier build --version "v1.0.0"

# 3. Commit the changelog
git add CHANGELOG.rst && git commit -m "doc: release notes for v1.0.0"
```

--------------------------------

### Project Release and Publication Workflow

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

A sequence of commands to validate the codebase, generate release notes using towncrier, tag the version, and publish the package to PyPI via twine. This process ensures consistent versioning and documentation for each release.

```bash
# 1. Ensure tests pass
uv run --extra test pytest -m pure

# 2. Build changelog (uses towncrier fragments in docs/newsfragments/)
uvx towncrier build --version "v1.0.0"

# 3. Commit the changelog
git add CHANGELOG.rst && git commit -m "doc: release notes for v1.0.0"

# 4. Tag the release (hatch-vcs derives the version from this tag)
git tag -a v1.0.0 -m "Version 1.0.0"

# 5. Build and publish
uv build
uvx twine upload dist/*
```

--------------------------------

### Run ASV Benchmarks Locally with Pixi

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/devnotes.org

Commands to run ASV benchmarks using a pixi-managed environment. This includes checking benchmark parsing, performing quick smoke tests, and executing full runs with sample recording. The '-E "existing:"' flag ensures ASV uses the pixi-managed Python interpreter.

```bash
# Validate that all benchmarks parse correctly
pixi run -e bench asv check

# Quick single-pass run (good for smoke testing)
pixi run -e bench asv run \
  -E "existing:$(pixi run -e bench which python)" \
  --quick

# Full run with sample recording
pixi run -e bench asv run \
  -E "existing:$(pixi run -e bench which python)" \
  --record-samples
```

--------------------------------

### Splitting CON Trajectory Files

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

Demonstrates how to use the con-splitter tool to decompose a multi-image trajectory file into individual frame files for new calculations.

```bash
rgpycrumbs eon con-splitter neb_final_path.con -o initial_images
```

--------------------------------

### Listing Available CLI Commands (Shell)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Displays the help message for the main rgpycrumbs CLI, listing available command groups and general usage information.

```shell
$ python -m rgpycrumbs.cli --help
Usage: rgpycrumbs [OPTIONS] COMMAND [ARGS]...

  A dispatcher that runs self-contained scripts using 'uv'.

Options:
  --help  Show this message and exit.

Commands:
  eon  Dispatches to a script within the 'eon' submodule.
```

--------------------------------

### Generate Configuration Files from Dictionaries

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/utils/jupyter.org

The write_eon_config function provides a safe way to generate configuration files (e.g., config.ini) from Python dictionaries. This avoids the fragility associated with manual string formatting.

```python
from rgpycrumbs.run.jupyter import write_eon_config

settings = {
    "Main": {"job": "nudged_elastic_band"},
    "Potential": {"potential": "Metatomic"},
}

# Writes to ./config.ini safely
write_eon_config(".", settings)
```

--------------------------------

### Plotting NEB Paths with Specific Range (Shell)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Executes the 'plt-neb' script to visualize NEB energy profiles from a specified range of data files and saves the output to a PDF.

```shell
python -m rgpycrumbs eon plt-neb --start 100 --end 150 -o final_path.pdf
```

--------------------------------

### Initialize Plausible Analytics Event Tracking (JavaScript)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/source/_templates/partials/extra-head.html

This snippet initializes the Plausible Analytics tracking object. It ensures that the `plausible` function is available globally, creating a queue if it doesn't exist, and prepares it to accept tracking events.

```javascript
window.plausible = window.plausible || function () { (window.plausible.q = window.plausible.q || []).push(arguments); };
```

--------------------------------

### CLI: prefix delete-packages

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/prefix/delete_packages.org

Deletes specified packages from a prefix.dev channel.

```APIDOC
## [CLI] prefix delete-packages

### Description
Removes packages from a custom prefix.dev channel. This command is invoked via the rgpycrumbs CLI.

### Method
CLI Command

### Endpoint
python -m rgpycrumbs.cli prefix delete-packages

### Parameters
#### Query Parameters
- **channel** (string) - Required - The name of the prefix.dev channel.
- **package** (string) - Required - The name of the package to delete.

### Request Example
python -m rgpycrumbs.cli prefix delete-packages --channel my-channel --package my-package

### Response
#### Success Response (0)
- **status** (string) - Indicates successful deletion of the package from the channel.

#### Response Example
{
  "status": "success",
  "message": "Package 'my-package' removed from 'my-channel'"
}
```

--------------------------------

### Basic rgpycrumbs CLI Structure (Shell)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/readme_src.org

Shows the general command structure for interacting with the rgpycrumbs command-line interface. This is used to dispatch to various subcommands and scripts.

```shell
python -m rgpycrumbs.cli [subcommand-group] [script-name] [script-options]
```

--------------------------------

### Invoking CLI Dispatcher Commands

Source: https://github.com/haozeke/rgpycrumbs/blob/main/README.md

Shows the general syntax for invoking CLI tools through the rgpycrumbs dispatcher. The dispatcher uses the uv runner to execute isolated scripts.

```bash
# General command structure
python -m rgpycrumbs.cli [subcommand-group] [script-name] [script-options]

# View available command groups
python -m rgpycrumbs.cli --help
```

--------------------------------

### Log eOn Configuration to MLFlow (Python)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/eon/mlflow.org

Logs hydrated eOn configurations from a local 'config.ini' file to an MLFlow tracking server. It supports uploading the config file as an artifact and tracking explicitly overridden parameters. Requires the 'mlflow' and 'rgpycrumbs' libraries.

```python
import mlflow
from rgpycrumbs.eon._mlflow.log_params import log_config_ini
from pathlib import Path

mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("eOn_Oxadiazole_Reaction")

with mlflow.start_run():
    # Log parameters from the local config file
    log_config_ini(
        Path("config.ini"),
        w_artifact=True,       # Upload file as artifact
        track_overrides=True   # Log 'Overrides/Section/Key' params
    )
    print("Configuration logged.")
```

--------------------------------

### Detect Fragments by Bond Order (CLI)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/geom/detect_fragments.org

Detect molecular fragments using the Wiberg Bond Order method, which is recommended for systems with ambiguous bonding like transition states or loosely bound complexes. This method requires the 'tblite' library and can be configured with a bond order threshold.

```shell
python -m rgpycrumbs.cli geom detect-fragments bond-order complex.xyz --threshold 0.6
```

--------------------------------

### Predicting Surface Values and Variances with Chunking

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/surfaces.org

Demonstrates how to use gradient-enhanced surface models for prediction and variance calculation, with internal chunking to manage memory for large query grids. The chunk_size parameter controls the batch size for predictions.

```python
model = GradientMatern(x_obs, y_obs, gradients=g_obs)
# Evaluates in chunks of 500 query points by default
z_preds = model(x_grid, chunk_size=1000)
z_vars = model.predict_var(x_grid, chunk_size=1000)
```

--------------------------------

### Detect Fragments Geometrically (CLI)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/geom/detect_fragments.org

Analyze molecular fragments using the geometric method via the command line. This method is suitable for standard organic molecules and relies on atomic radii similar to ASE visualizations. It accepts single XYZ files or can process a directory of structures in batch mode.

```shell
python -m rgpycrumbs.cli geom detect-fragments geometric molecule.xyz --multiplier 1.2

python -m rgpycrumbs.cli geom detect-fragments batch ./structures/ --output summary.csv
```

--------------------------------

### Running Tests via Pixi

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

Commands for executing specific test suites within isolated pixi environments. Users must match the environment name with the corresponding pytest marker.

```shell
# Run tests for a specific suite
pixi run -e <env_name> pytest -m <marker_name>

# Examples
pixi run -e test pytest -m pure
pixi run -e test pytest -m align
pixi run -e surfaces pytest -m surfaces
pixi run -e fragments pytest -m fragments
```

--------------------------------

### Conditional Test Execution with Markers

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

Demonstrates how to import scripts with heavy dependencies safely by using pytest markers and environment guards. This prevents import errors during test collection in environments lacking specific dependencies.

```python
import pytest
from tests.conftest import skip_if_not_env

skip_if_not_env("eon")

from rgpycrumbs.eon.plt_neb import main as plt_neb_main  # noqa: E402

pytestmark = pytest.mark.eon

def test_plt_neb_help(runner):
    result = runner.invoke(plt_neb_main, ["--help"])
    assert result.exit_code == 0
```

--------------------------------

### Plot NEB Paths (CLI)

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/eon/plt_neb.org

Command-line interface for plotting NEB paths. It allows specifying a range of neb_*.dat files to plot and saving the output to a PDF file. Dependencies include the rgpycrumbs library.

```shell
python -m rgpycrumbs.cli eon plt-neb --start 10 --end 15 -o final_path.pdf
```

```shell
python -m rgpycrumbs.cli eon plt-neb --start 280
```

--------------------------------

### Structure Test Files with Environment Guards

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

Provides a template for test files, showing how to use skip_if_not_env to prevent import errors during pytest collection.

```python
import pytest
from tests.conftest import skip_if_not_env

# Guard collection: prevents imports from executing if dependencies are missing
skip_if_not_env("my_marker")
```

--------------------------------

### Execute Subprocess with Real-time Streaming in Jupyter

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/utils/jupyter.org

The run_command_or_exit function executes shell commands and streams stdout/stderr directly to the notebook cell. It is designed for long-running simulation jobs and will raise a SystemExit if the command fails, preventing further execution.

```python
from rgpycrumbs.run.jupyter import run_command_or_exit

# Runs 'eonclient', streams output, and raises SystemExit on failure
# This prevents the notebook from continuing if the simulation crashes.
run_command_or_exit(["eonclient"], timeout=300)
```

--------------------------------

### Subprocess Dispatcher Invocation

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/devnotes.org

This Python snippet demonstrates the core logic of the rgpycrumbs dispatcher. It uses the `subprocess.run` function to execute a script via `uv run`, passing along any additional arguments. This ensures that each script runs in an isolated environment with its specific dependencies.

```python
# Logic captured in rgpycrumbs/cli.py
subprocess.run(["uv", "run", script_path] + args)
```

--------------------------------

### Debug Execution with Verbose Mode

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

Uses the verbose flag to inspect the resolved script paths and the underlying command array constructed by the dispatcher.

```shell
# Check standard isolated execution
rgpycrumbs --verbose mygroup myscript

# Check local development execution
rgpycrumbs --dev -v mygroup myscript
```

--------------------------------

### PTM Displacement

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/tools/eon/ptmdisp.org

Identifies atoms in a structure file that do not match a specified crystal structure (e.g., FCC) using Polyhedral Template Matching (PTM). It outputs the 0-based indices of these defect atoms (e.g., interstitials), which is useful for filtering or setting up atom lists for the displacements used for eOn calculations.

```APIDOC
## PTM Displacement

### Description
Identifies atoms in a structure file that do not match a specified crystal structure (e.g., FCC) using Polyhedral Template Matching (PTM). It outputs the 0-based indices of these defect atoms (e.g., interstitials), which is useful for filtering or setting up atom lists for the displacements used for eOn calculations.

### Method
POST

### Endpoint
/haozeke/rgpycrumbs/eon/ptmdisp

### Parameters
#### Query Parameters
- **structure_file** (string) - Required - Path to the structure file.
- **template_structure** (string) - Required - The crystal structure to match against (e.g., 'FCC').

#### Request Body
(No request body specified for this endpoint)

### Request Example
(No request example provided)

### Response
#### Success Response (200)
- **defect_atom_indices** (list of int) - A list of 0-based indices of the atoms that do not match the template structure.

#### Response Example
```json
{
  "defect_atom_indices": [10, 25, 31]
}
```
```

--------------------------------

### Core Feature Validation

Source: https://github.com/haozeke/rgpycrumbs/blob/main/docs/orgmode/contributing/test_requirements.org

A basic unit test verifying the core functionality of the rgpycrumbs submodule. It ensures that the core_feature function returns True.

```python
from rgpycrumbs.submodule.logic import core_feature

def test_feature_execution():
    assert core_feature() is True
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.