quantized-lab 0.8.0__py3-none-any.whl

quantized/routes/reference.py

@@ -0,0 +1,58 @@
+"""Thin reference-data routes: physical constants, element table, unit convert.
+
+Wraps the finished W4 backend helpers (``calc.constants``, ``calc.element_data``,
+``calc.unit_convert``). Pure lookups + a unit-expression converter; no logic here.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, ConfigDict, Field
+
+from quantized.calc.constants import constants
+from quantized.calc.element_data import by_symbol, element_data
+from quantized.calc.unit_convert import unit_convert
+from quantized.routes._payload import to_jsonable
+
+router = APIRouter(prefix="/api/reference", tags=["reference"])
+
+
+class ConvertRequest(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    value: float | list[float]
+    from_unit: str = Field(alias="from")
+    to_unit: str = Field(alias="to")
+
+
+@router.get("/constants")
+def get_constants() -> dict[str, Any]:
+    """CODATA physical constants (name -> value)."""
+    return {"constants": to_jsonable(constants())}
+
+
+@router.get("/elements")
+def get_elements() -> dict[str, Any]:
+    """The full 118-element table."""
+    return {"elements": to_jsonable(element_data())}
+
+
+@router.get("/elements/{symbol}")
+def get_element(symbol: str) -> dict[str, Any]:
+    """One element by symbol (e.g. ``Fe``)."""
+    try:
+        return to_jsonable(by_symbol(symbol))  # type: ignore[no-any-return]
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.post("/convert")
+def convert(req: ConvertRequest) -> dict[str, Any]:
+    """Convert a value between unit expressions (e.g. ``Oe`` -> ``T``)."""
+    try:
+        result, info = unit_convert(req.value, req.from_unit, req.to_unit)
+    except (ValueError, KeyError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {"result": to_jsonable(result), "info": to_jsonable(info)}

quantized/routes/reflectivity.py

@@ -0,0 +1,91 @@
+"""Thin specular-reflectivity routes.
+
+Wraps the finished W3 calc helpers (``calc.reflectivity.parratt_refl`` — golden vs
+MATLAB parrattRefl — and ``calc.sld`` SLD profile / presets). The route builds the
+Q grid, validates the layer stack, calls the pure functions, and serializes. No
+physics here; the recursion + Névot-Croce roughness live in ``calc/``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from quantized.calc.reflectivity import parratt_refl
+from quantized.calc.sld import refl_sld_presets, sld_profile
+from quantized.routes._payload import to_jsonable
+
+router = APIRouter(prefix="/api/reflectivity", tags=["reflectivity"])
+
+# A layer row is [thickness Å, SLD_real Å⁻², SLD_imag Å⁻², roughness Å].
+Layer = list[float]
+
+
+class SimulateRequest(BaseModel):
+    """Simulate R(Q) from a layer stack over a linear Q grid."""
+
+    layers: list[Layer] = Field(min_length=2)
+    q_min: float = Field(default=0.005, gt=0.0)
+    q_max: float = Field(default=0.25, gt=0.0)
+    n_points: int = Field(default=400, ge=2, le=20000)
+    roughness: bool = True
+    scale: float = 1.0
+    background: float = 0.0
+    resolution: float | None = None  # dQ/Q (constant relative resolution)
+
+
+class SldProfileRequest(BaseModel):
+    """SLD(z) depth profile from a layer stack (error-function interfaces)."""
+
+    layers: list[Layer] = Field(min_length=2)
+    n_points: int = Field(default=500, ge=2, le=20000)
+    padding: float = Field(default=50.0, ge=0.0)
+
+
+def _validate_layers(layers: list[Layer]) -> None:
+    if any(len(row) != 4 for row in layers):
+        raise HTTPException(
+            status_code=422,
+            detail="each layer must be [thickness, sld_real, sld_imag, roughness]",
+        )
+
+
+@router.get("/presets")
+def get_presets() -> dict[str, Any]:
+    """Material SLD presets (name/formula/sldX/sldN/sldImag/density)."""
+    return {"presets": to_jsonable(refl_sld_presets())}
+
+
+@router.post("/simulate")
+def simulate(req: SimulateRequest) -> dict[str, Any]:
+    """Specular reflectivity R(Q) for the layer stack over [q_min, q_max]."""
+    _validate_layers(req.layers)
+    if req.q_max <= req.q_min:
+        raise HTTPException(status_code=422, detail="q_max must exceed q_min")
+    q = np.linspace(req.q_min, req.q_max, req.n_points)
+    try:
+        r = parratt_refl(
+            q,
+            req.layers,
+            roughness=req.roughness,
+            scale=req.scale,
+            background=req.background,
+            resolution=req.resolution,
+        )
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {"q": to_jsonable(q), "r": to_jsonable(r)}
+
+
+@router.post("/sld-profile")
+def sld_profile_route(req: SldProfileRequest) -> dict[str, Any]:
+    """SLD(z) depth profile (error-function interfaces) for the layer stack."""
+    _validate_layers(req.layers)
+    try:
+        z, sld = sld_profile(req.layers, n_points=req.n_points, padding=req.padding)
+    except (ValueError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return {"z": to_jsonable(z), "sld": to_jsonable(sld)}

quantized/routes/report_export.py

@@ -0,0 +1,119 @@
+"""Thin routes: emit + render report sheets (#36/#37/#38).
+
+``/emit`` maps an analysis result dict onto the #36 schema via the pure
+``calc.report_emit`` emitters (one emission source of truth — the frontend
+never re-shapes results itself). ``/export`` validates a posted report and
+streams the rendered LaTeX / HTML / Word / PowerPoint file back as an
+attachment. Missing optional office libraries surface as 501; unknown
+formats/kinds as 422.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import UTC, datetime
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Response
+from pydantic import BaseModel
+
+from quantized.calc import report_emit
+from quantized.calc.report import ReportSheet, validate_report
+from quantized.io.report_export import ReportExportError, render_report
+
+router = APIRouter(prefix="/api/report", tags=["report"])
+
+_EXT = {"latex": ".tex", "html": ".html", "docx": ".docx", "pptx": ".pptx"}
+
+
+def _safe_name(name: str, ext: str) -> str:
+    stem = re.sub(r"[^A-Za-z0-9._-]", "_", name).strip("._") or "report"
+    return stem if stem.endswith(ext) else stem + ext
+
+
+class ReportEmitRequest(BaseModel):
+    """An analysis result + which emitter should shape it into a report."""
+
+    kind: str  # curve_fit | multipeak_fit | integrate | batch_integrate | anova | stats_table
+    result: dict[str, Any] | None = None
+    records: list[dict[str, Any]] | None = None  # stats_table input
+    title: str | None = None
+    model_name: str | None = None
+    param_names: list[str] | None = None
+    param_units: list[str] | None = None
+    columns: list[str] | None = None
+    caption: str | None = None
+    source_refs: list[dict[str, Any]] = []
+
+
+def _emit_sheet(req: ReportEmitRequest) -> ReportSheet:
+    """Dispatch to the matching pure emitter (no eval — explicit table)."""
+    kind = req.kind
+    refs = req.source_refs
+    if kind == "stats_table":
+        if not req.records:
+            raise ValueError("stats_table needs non-empty 'records'")
+        return report_emit.from_stats_table(
+            req.records, title=req.title or "Statistics",
+            columns=req.columns, caption=req.caption, source_refs=refs,
+        )
+    if req.result is None:
+        raise ValueError(f"kind {kind!r} needs a 'result' object")
+    if kind == "curve_fit":
+        return report_emit.from_curve_fit(
+            req.result, param_names=req.param_names or [],
+            param_units=req.param_units, title=req.title or "Curve fit",
+            model_name=req.model_name, source_refs=refs,
+        )
+    simple = {
+        "multipeak_fit": report_emit.from_multipeak_fit,
+        "integrate": report_emit.from_integrate,
+        "batch_integrate": report_emit.from_batch_integrate,
+        "anova": report_emit.from_anova,
+    }
+    if kind not in simple:
+        raise ValueError(f"unknown report kind {kind!r}")
+    kwargs: dict[str, Any] = {"source_refs": refs}
+    if req.title:
+        kwargs["title"] = req.title
+    return simple[kind](req.result, **kwargs)
+
+
+@router.post("/emit")
+def emit_report(req: ReportEmitRequest) -> dict[str, Any]:
+    """Result dict + kind -> a validated #36 report sheet (JSON)."""
+    try:
+        sheet = _emit_sheet(req)
+    except (ValueError, KeyError, TypeError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    payload = sheet.to_dict()
+    # calc stays deterministic/pure; the route stamps the creation time.
+    payload["created"] = datetime.now(UTC).isoformat(timespec="seconds")
+    return {"report": payload}
+
+
+class ReportExportRequest(BaseModel):
+    report: dict[str, Any]
+    format: str = "html"
+    filename: str = "report"
+
+
+@router.post("/export")
+def export_report(req: ReportExportRequest) -> Response:
+    """Report dict + format -> downloadable file (.tex/.html/.docx/.pptx)."""
+    try:
+        validate_report(req.report)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    try:
+        data, mime, _is_text = render_report(req.report, req.format)
+    except ReportExportError as exc:
+        # unknown format -> 422; a missing optional office lib -> 501
+        code = 501 if "needs" in str(exc) else 422
+        raise HTTPException(status_code=code, detail=str(exc)) from exc
+    filename = _safe_name(req.filename, _EXT.get(req.format, ""))
+    return Response(
+        content=data,
+        media_type=mime,
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )

quantized/routes/rsm.py

@@ -0,0 +1,136 @@
+"""Thin RSM route: substrate/film reciprocal-space peaks -> strain + relaxation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from quantized.calc.linecut import cut_segment, line_cut, projection
+from quantized.calc.rsm import rsm_strain
+from quantized.calc.rsm_analyze import rsm_analyze, rsm_grids_from_datastruct
+from quantized.datastruct import DataStruct
+from quantized.routes._payload import datastruct_payload, to_jsonable
+
+router = APIRouter(prefix="/api/rsm", tags=["rsm"])
+
+
+class StrainRequest(BaseModel):
+    """Reciprocal-space peak centres ``(Qx, Qz)`` in Ang^-1."""
+
+    q_sub: tuple[float, float]
+    q_film: tuple[float, float]
+    bulk: tuple[float, float] | None = None
+
+
+@router.post("/strain")
+def strain(req: StrainRequest) -> dict[str, Any]:
+    """In-plane / out-of-plane strain + relaxation from an RSM peak pair."""
+    try:
+        result = rsm_strain(req.q_sub, req.q_film, bulk=req.bulk)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    # NaN (symmetric reflection / no bulk) -> null for valid wire JSON.
+    return to_jsonable(result)  # type: ignore[no-any-return]
+
+
+class AnalyzeRequest(BaseModel):
+    """A scattered 2D RSM dataset (from the XRDML 2D parser) + detection options."""
+
+    dataset: dict[str, Any]
+    n_peaks: int = Field(default=2, ge=1, le=20)
+    threshold: float = Field(default=0.01, ge=0.0)
+    smooth_sigma: float = Field(default=1.5, gt=0.0)
+    min_separation: int = Field(default=4, ge=1)
+    fit_window: int = Field(default=6, ge=1)
+    fit_model: str = "2D Gaussian"
+
+
+@router.post("/analyze")
+def analyze(req: AnalyzeRequest) -> dict[str, Any]:
+    """Extract + fit peaks from a 2D RSM dataset (centres/FWHM in angle + Q-space)."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        grids = rsm_grids_from_datastruct(ds)
+        result = rsm_analyze(
+            grids["intensity"],
+            grids["axis1"],
+            grids["axis2"],
+            qx=grids["qx"],
+            qz=grids["qz"],
+            n_peaks=req.n_peaks,
+            threshold=req.threshold,
+            smooth_sigma=req.smooth_sigma,
+            min_separation=req.min_separation,
+            fit_window=req.fit_window,
+            fit_model=req.fit_model,
+            intensity_unit=grids["intensity_unit"],
+        )
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return to_jsonable(result)  # type: ignore[no-any-return]
+
+
+class LineCutRequest(BaseModel):
+    """Fixed-axis cut through a 2-D map dataset (H/V, angular or Q space)."""
+
+    dataset: dict[str, Any]
+    direction: str  # "h" | "v"
+    value: float
+    space: str = "angular"
+    width: float = Field(default=0.0, ge=0.0)
+
+
+@router.post("/linecut")
+def linecut(req: LineCutRequest) -> dict[str, Any]:
+    """H/V line cut -> a 1-D DataStruct (width>0 averages a swath)."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        out = line_cut(
+            ds, direction=req.direction, value=req.value, space=req.space, width=req.width
+        )
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return datastruct_payload(out)
+
+
+class CutSegmentRequest(BaseModel):
+    """Arbitrary straight cut p0 -> p1 through the scattered 2-D cloud."""
+
+    dataset: dict[str, Any]
+    p0: tuple[float, float]
+    p1: tuple[float, float]
+    n: int = Field(default=200, ge=2, le=1_000_000)
+    width: float = Field(default=0.0, ge=0.0)
+    space: str = "angular"
+
+
+@router.post("/cut-segment")
+def cut_segment_route(req: CutSegmentRequest) -> dict[str, Any]:
+    """Arbitrary-angle segment cut -> a distance-parametrized 1-D DataStruct."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        out = cut_segment(ds, p0=req.p0, p1=req.p1, n=req.n, width=req.width, space=req.space)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return datastruct_payload(out)
+
+
+class ProjectionRequest(BaseModel):
+    """Integrate the whole map onto one axis."""
+
+    dataset: dict[str, Any]
+    axis: str = "pixels"  # "pixels" (I vs 2theta) | "frames" (I vs omega)
+    space: str = "angular"
+
+
+@router.post("/projection")
+def projection_route(req: ProjectionRequest) -> dict[str, Any]:
+    """Full-map integrated profile -> a 1-D DataStruct."""
+    try:
+        ds = DataStruct.from_dict(req.dataset)
+        out = projection(ds, axis=req.axis, space=req.space)
+    except (ValueError, KeyError, IndexError) as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    return datastruct_payload(out)

quantized/routes/samples.py

@@ -0,0 +1,32 @@
+"""Thin route serving the bundled first-run demo dataset.
+
+A tiny synthetic hysteresis-loop CSV (``samples/demo_vsm.csv`` — generated,
+never real instrument data) ships inside the package so a fresh install has
+something to plot with zero setup. :func:`quantized.io.import_auto` parses it
+through the exact same path as any user file, so the response is an ordinary
+DataStruct import payload, not a special-cased shape.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+
+from quantized.io import import_auto
+from quantized.routes._payload import datastruct_payload
+
+router = APIRouter(prefix="/api/samples", tags=["samples"])
+
+_DEMO_FILE = Path(__file__).resolve().parent.parent / "samples" / "demo_vsm.csv"
+
+
+@router.get("/demo")
+def get_demo() -> dict[str, Any]:
+    """The bundled first-run demo dataset (a synthetic VSM-like hysteresis loop)."""
+    if not _DEMO_FILE.is_file():
+        # Only possible on a broken install (samples/ stripped from the
+        # wheel) — fail loudly instead of silently returning nothing.
+        raise HTTPException(status_code=500, detail=f"demo sample missing: {_DEMO_FILE.name}")
+    return datastruct_payload(import_auto(_DEMO_FILE))

quantized/routes/semiconductor.py

@@ -0,0 +1,207 @@
+"""Thin semiconductor device-physics routes. Wraps ``calc.semiconductor`` (pure
+formulas): intrinsic carrier concentration / carrier concentrations / depletion
+width / diffusion coefficient + length / Fermi level / Debye length / built-in
+potential / sheet carrier density / thermal velocity / Hall coefficient /
+mobility model. Validate -> call the pure fn -> serialize.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc import semiconductor
+
+router = APIRouter(prefix="/api/semiconductor", tags=["semiconductor"])
+
+
+class IntrinsicRequest(BaseModel):
+    eg: float | None = None
+    me_star: float | None = None
+    mh_star: float | None = None
+    t: float = 300.0
+    material: str | None = None
+
+
+class CarrierConcRequest(BaseModel):
+    nd: float
+    na: float
+    ni: float
+
+
+class BuiltInPotentialRequest(BaseModel):
+    na: float
+    nd: float
+    ni: float
+    t: float = 300.0
+
+
+class DepletionWidthRequest(BaseModel):
+    vbi: float
+    na: float
+    nd: float
+    epsilon_r: float | None = None
+    material: str | None = None
+    t: float = 300.0
+
+
+class DiffusionCoeffRequest(BaseModel):
+    mu: float
+    t: float = 300.0
+
+
+class DiffusionLengthRequest(BaseModel):
+    d: float
+    tau: float
+
+
+class FermiLevelRequest(BaseModel):
+    eg: float | None = None
+    me_star: float | None = None
+    mh_star: float | None = None
+    nd: float = 0.0
+    na: float = 0.0
+    t: float = 300.0
+    material: str | None = None
+
+
+class DebyeLengthRequest(BaseModel):
+    n: float
+    epsilon_r: float | None = None
+    t: float = 300.0
+    material: str | None = None
+
+
+class SheetCarrierRequest(BaseModel):
+    n: float
+    t: float
+
+
+class ThermalVelocityRequest(BaseModel):
+    m_star: float
+    t: float = 300.0
+
+
+class HallCoefficientRequest(BaseModel):
+    n: float
+    p: float
+    mu_e: float
+    mu_h: float
+
+
+class MobilityModelRequest(BaseModel):
+    material: str = "Si"
+    t: float = 300.0
+    n: float = 0.0
+
+
+def _call(fn: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> dict[str, Any]:
+    try:
+        return fn(*args, **kwargs)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+
+@router.get("/materials")
+def materials() -> dict[str, Any]:
+    """Material-parameter presets (Eg, εᵣ, mₑ*, m_h*)."""
+    return {"materials": semiconductor.material_presets()}
+
+
+@router.post("/intrinsic")
+def intrinsic(req: IntrinsicRequest) -> dict[str, Any]:
+    """n_i = √(N_c N_v)·exp(−E_g/2k_BT) (cm⁻³)."""
+    return _call(
+        semiconductor.intrinsic_carrier_conc,
+        req.eg,
+        req.me_star,
+        req.mh_star,
+        req.t,
+        req.material,
+    )
+
+
+@router.post("/carrier-concentration")
+def carrier_concentration(req: CarrierConcRequest) -> dict[str, Any]:
+    """n, p from charge-neutrality + mass-action; doping type."""
+    return _call(semiconductor.carrier_concentration, req.nd, req.na, req.ni)
+
+
+@router.post("/built-in-potential")
+def built_in_potential(req: BuiltInPotentialRequest) -> dict[str, Any]:
+    """V_bi = (k_BT/q)·ln(N_a N_d / n_i²) (V)."""
+    return _call(semiconductor.built_in_potential, req.na, req.nd, req.ni, req.t)
+
+
+@router.post("/depletion-width")
+def depletion_width(req: DepletionWidthRequest) -> dict[str, Any]:
+    """Depletion width W, x_n, x_p (nm)."""
+    return _call(
+        semiconductor.depletion_width,
+        req.vbi,
+        req.na,
+        req.nd,
+        req.epsilon_r,
+        req.material,
+        req.t,
+    )
+
+
+@router.post("/diffusion-coeff")
+def diffusion_coeff(req: DiffusionCoeffRequest) -> dict[str, Any]:
+    """D = μ·k_BT/q (cm²/s)."""
+    return _call(semiconductor.diffusion_coeff, req.mu, req.t)
+
+
+@router.post("/diffusion-length")
+def diffusion_length(req: DiffusionLengthRequest) -> dict[str, Any]:
+    """L = √(D·τ) (cm / µm)."""
+    return _call(semiconductor.diffusion_length, req.d, req.tau)
+
+
+@router.post("/fermi-level")
+def fermi_level(req: FermiLevelRequest) -> dict[str, Any]:
+    """E_F − E_i = k_BT·asinh(Δ/2n_i) (eV)."""
+    return _call(
+        semiconductor.fermi_level,
+        req.eg,
+        req.me_star,
+        req.mh_star,
+        req.nd,
+        req.na,
+        req.t,
+        req.material,
+    )
+
+
+@router.post("/debye-length")
+def debye_length(req: DebyeLengthRequest) -> dict[str, Any]:
+    """L_D = √(ε₀εᵣk_BT/(q²n)) (nm)."""
+    return _call(semiconductor.debye_length, req.n, req.epsilon_r, req.t, req.material)
+
+
+@router.post("/sheet-carrier-density")
+def sheet_carrier_density(req: SheetCarrierRequest) -> dict[str, Any]:
+    """n_s = n·t (cm⁻²)."""
+    return _call(semiconductor.sheet_carrier_density, req.n, req.t)
+
+
+@router.post("/thermal-velocity")
+def thermal_velocity(req: ThermalVelocityRequest) -> dict[str, Any]:
+    """v_th = √(3k_BT/(m* m₀)) (cm/s)."""
+    return _call(semiconductor.thermal_velocity, req.m_star, req.t)
+
+
+@router.post("/hall-coefficient")
+def hall_coefficient(req: HallCoefficientRequest) -> dict[str, Any]:
+    """R_H = (1/q)(pμ_h² − nμ_e²)/(pμ_h + nμ_e)² (cm³/C)."""
+    return _call(semiconductor.hall_coefficient, req.n, req.p, req.mu_e, req.mu_h)
+
+
+@router.post("/mobility-model")
+def mobility_model(req: MobilityModelRequest) -> dict[str, Any]:
+    """Caughey-Thomas μ_e, μ_h (cm²/V·s)."""
+    return _call(semiconductor.mobility_model, req.material, req.t, req.n)

quantized/routes/sld.py

@@ -0,0 +1,42 @@
+"""Thin SLD-from-formula route. Wraps ``calc.sld_formula`` (pure).
+
+One endpoint computes neutron + X-ray scattering-length densities (with the
+imaginary/absorption parts) from a chemical formula, mass density, and probe
+wavelengths. The physics lives in calc; this only validates + serializes.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from quantized.calc.sld_formula import (
+    NEUTRON_WAVELENGTH,
+    XRAY_WAVELENGTH,
+    sld_from_formula,
+)
+
+router = APIRouter(prefix="/api/sld", tags=["sld"])
+
+
+class SldRequest(BaseModel):
+    formula: str
+    density: float
+    neutron_wavelength: float = NEUTRON_WAVELENGTH
+    xray_wavelength: float = XRAY_WAVELENGTH
+
+
+@router.post("/formula")
+def formula(req: SldRequest) -> dict[str, Any]:
+    """Neutron + X-ray SLD (real + imaginary) for a formula at a mass density."""
+    try:
+        return sld_from_formula(
+            req.formula,
+            req.density,
+            neutron_wavelength=req.neutron_wavelength,
+            xray_wavelength=req.xray_wavelength,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc