quantized-lab 0.8.0__py3-none-any.whl

quantized/routes/thin_film.py

@@ -0,0 +1,153 @@
+"""Thin-film calculator routes. Wraps ``calc.thin_film`` (pure formulas):
+deposition / sputter rate, diffusion length, implant dose + peak concentration,
+Kiessig thickness, multilayer thermal conductivity, projected range, Stoney
+stress, thermal-mismatch strain. 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 thin_film
+
+router = APIRouter(prefix="/api/thin-film", tags=["thin-film"])
+
+
+class DepositionRateRequest(BaseModel):
+    thickness: float  # Å
+    time: float  # s
+
+
+class DiffusionLengthRequest(BaseModel):
+    d: float  # cm^2/s
+    t: float  # s
+
+
+class DoseFromCurrentRequest(BaseModel):
+    current: float  # A
+    time: float  # s
+    area: float  # cm^2
+
+
+class DoseToConcentrationRequest(BaseModel):
+    dose: float  # ions/cm^2
+    rp: float  # nm
+    delta_rp: float  # nm
+
+
+class KiessigRequest(BaseModel):
+    delta_q: float  # Å^-1
+    sld: float | None = None  # Å^-2
+    qc: float | None = None  # Å^-1
+
+
+class MultilayerThermalRequest(BaseModel):
+    thicknesses: list[float]  # nm
+    kappas: list[float]  # W/m/K
+
+
+class ProjectedRangeRequest(BaseModel):
+    ion: str
+    target: str
+    energy: float  # keV
+
+
+class SputterRateRequest(BaseModel):
+    y: float  # atoms/ion
+    j: float  # mA/cm^2
+    rho: float  # g/cm^3
+    m: float  # g/mol
+
+
+class StoneyStressRequest(BaseModel):
+    es: float  # Pa
+    nus: float
+    ts: float  # m
+    tf: float  # m
+    r: float  # m
+
+
+class ThermalMismatchRequest(BaseModel):
+    alpha_film: float  # 1/K
+    alpha_sub: float  # 1/K
+    delta_t: float  # K
+    e: float | None = None  # Pa
+    nu: float = 0.3
+
+
+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.post("/deposition-rate")
+def deposition_rate(req: DepositionRateRequest) -> dict[str, Any]:
+    """r = thickness/time (Å/s, nm/min)."""
+    return _call(thin_film.deposition_rate, req.thickness, req.time)
+
+
+@router.post("/diffusion-length")
+def diffusion_length(req: DiffusionLengthRequest) -> dict[str, Any]:
+    """L = √(D·t) (cm/nm/µm)."""
+    return _call(thin_film.diffusion_length_thermal, req.d, req.t)
+
+
+@router.post("/dose-from-current")
+def dose_from_current(req: DoseFromCurrentRequest) -> dict[str, Any]:
+    """Φ = I·t/(q·A) (ions/cm²)."""
+    return _call(thin_film.dose_from_current, req.current, req.time, req.area)
+
+
+@router.post("/dose-to-concentration")
+def dose_to_concentration(req: DoseToConcentrationRequest) -> dict[str, Any]:
+    """C_peak = dose/(√(2π)·ΔRp) (atoms/cm³)."""
+    return _call(thin_film.dose_to_concentration, req.dose, req.rp, req.delta_rp)
+
+
+@router.post("/kiessig-thickness")
+def kiessig_thickness(req: KiessigRequest) -> dict[str, Any]:
+    """t = 2π/ΔQ (refraction-corrected when SLD/Qc supplied)."""
+    return _call(thin_film.kiessig_thickness, req.delta_q, sld=req.sld, qc=req.qc)
+
+
+@router.post("/multilayer-thermal")
+def multilayer_thermal(req: MultilayerThermalRequest) -> dict[str, Any]:
+    """Series / parallel effective thermal conductivity (W/m/K)."""
+    return _call(thin_film.multilayer_thermal_conductivity, req.thicknesses, req.kappas)
+
+
+@router.post("/projected-range")
+def projected_range(req: ProjectedRangeRequest) -> dict[str, Any]:
+    """LSS projected range Rp + straggle ΔRp (nm)."""
+    return _call(thin_film.projected_range, req.ion, req.target, req.energy)
+
+
+@router.post("/sputter-rate")
+def sputter_rate(req: SputterRateRequest) -> dict[str, Any]:
+    """Sputter erosion rate (nm/s, nm/min)."""
+    return _call(thin_film.sputter_rate, req.y, req.j, req.rho, req.m)
+
+
+@router.post("/stoney-stress")
+def stoney_stress(req: StoneyStressRequest) -> dict[str, Any]:
+    """σ = E_s·t_s²/(6(1−ν_s)·t_f·R) (Pa)."""
+    return _call(thin_film.stoney_stress, req.es, req.nus, req.ts, req.tf, req.r)
+
+
+@router.post("/thermal-mismatch")
+def thermal_mismatch(req: ThermalMismatchRequest) -> dict[str, Any]:
+    """ε = (α_f−α_s)·ΔT, σ = E·ε/(1−ν) (MPa)."""
+    return _call(
+        thin_film.thermal_mismatch_strain,
+        req.alpha_film,
+        req.alpha_sub,
+        req.delta_t,
+        e=req.e,
+        nu=req.nu,
+    )

quantized/routes/vacuum.py

@@ -0,0 +1,113 @@
+"""Thin vacuum-science routes. Wraps ``calc.vacuum`` (pure formulas): mean free
+path / monolayer time / sputter yield / pump-down time / Knudsen number / gas
+flow conductance. 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 vacuum
+
+router = APIRouter(prefix="/api/vacuum", tags=["vacuum"])
+
+
+class MeanFreePathRequest(BaseModel):
+    p: float
+    temperature: float = 300.0
+    d: float = 3.64e-10
+
+
+class MonolayerTimeRequest(BaseModel):
+    p: float
+    m: float = 4.65e-26
+    temperature: float = 300.0
+    a_site: float = 1e-19
+
+
+class KnudsenRequest(BaseModel):
+    mfp: float
+    length: float
+
+
+class PumpDownRequest(BaseModel):
+    v: float
+    s: float
+    p0: float
+    pf: float
+
+
+class SputterYieldRequest(BaseModel):
+    material: str
+    energy: float
+    ion: str = "Ar"
+
+
+class GasFlowRequest(BaseModel):
+    p1: float
+    p2: float
+    d: float
+    length: float
+    temperature: float = 300.0
+    m: float = 4.65e-26
+
+
+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.post("/mean-free-path")
+def mean_free_path(req: MeanFreePathRequest) -> dict[str, Any]:
+    """λ = k_B·T / (√2·π·d²·P) (m)."""
+    return _call(vacuum.mean_free_path, req.p, temperature=req.temperature, d=req.d)
+
+
+@router.post("/monolayer-time")
+def monolayer_time(req: MonolayerTimeRequest) -> dict[str, Any]:
+    """t_mono = 1/(J·A_site) (s)."""
+    return _call(
+        vacuum.monolayer_time,
+        req.p,
+        m=req.m,
+        temperature=req.temperature,
+        a_site=req.a_site,
+    )
+
+
+@router.post("/knudsen")
+def knudsen(req: KnudsenRequest) -> dict[str, Any]:
+    """Kn = λ/L plus flow regime."""
+    return _call(vacuum.knudsen_number, req.mfp, req.length)
+
+
+@router.post("/pump-down")
+def pump_down(req: PumpDownRequest) -> dict[str, Any]:
+    """t = (V/S)·ln(P0/Pf) (s)."""
+    return _call(vacuum.pump_down_time, req.v, req.s, req.p0, req.pf)
+
+
+@router.post("/sputter-yield")
+def sputter_yield(req: SputterYieldRequest) -> dict[str, Any]:
+    """Y (atoms/ion) from the Ar-ion lookup table; NaN outside range."""
+    return _call(vacuum.sputter_yield, req.material, req.energy, ion=req.ion)
+
+
+@router.post("/gas-flow")
+def gas_flow(req: GasFlowRequest) -> dict[str, Any]:
+    """Molecular & viscous gas-flow conductance through a tube (L/s)."""
+    return _call(
+        vacuum.gas_flow,
+        req.p1,
+        req.p2,
+        req.d,
+        req.length,
+        temperature=req.temperature,
+        m=req.m,
+    )

quantized/routes/xray.py

@@ -0,0 +1,32 @@
+"""Thin X-ray / neutron calculator route. Wraps ``calc.xray`` (pure formulas).
+
+One endpoint dispatches the Bragg / Q↔2θ scalar conversions by ``mode``; the
+math 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.xray import xray_calc
+
+router = APIRouter(prefix="/api/xray", tags=["xray"])
+
+
+class XrayCalcRequest(BaseModel):
+    mode: str
+    wavelength: float
+    value: float
+    n: int = 1
+
+
+@router.post("/calc")
+def calc(req: XrayCalcRequest) -> dict[str, Any]:
+    """Bragg / Q↔2θ conversion. ``mode`` selects the quantity (see calc.xray)."""
+    try:
+        return xray_calc(req.mode, req.wavelength, req.value, req.n)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc

quantized/samples/demo_vsm.csv

@@ -0,0 +1,42 @@
+Field (Oe),Moment (emu)
+-5000.0,-4.0000
+-4750.0,-3.9500
+-4500.0,-3.9000
+-4250.0,-3.8500
+-4000.0,-3.8000
+-3750.0,-3.7500
+-3500.0,-3.7000
+-3250.0,-3.6500
+-3000.0,-3.6000
+-2750.0,-3.5500
+-2500.0,-3.5000
+-2250.0,-3.4500
+-2000.0,-3.4000
+-1750.0,-3.3500
+-1500.0,-3.2999
+-1250.0,-3.2498
+-1000.0,-3.1993
+-750.0,-3.1474
+-500.0,-3.0910
+-250.0,-3.0187
+0.0,-2.8921
+250.0,-2.5895
+500.0,-1.8054
+750.0,-0.2231
+1000.0,1.5864
+1250.0,2.6779
+1500.0,3.1241
+1750.0,3.2985
+2000.0,3.3852
+2250.0,3.4457
+2500.0,3.4988
+2750.0,3.5497
+3000.0,3.5999
+3250.0,3.6500
+3500.0,3.7000
+3750.0,3.7500
+4000.0,3.8000
+4250.0,3.8500
+4500.0,3.9000
+4750.0,3.9500
+5000.0,4.0000

quantized/server_launch.py

@@ -0,0 +1,251 @@
+"""Desktop (``--desktop``, pywebview) and dev (``--dev``, Vite HMR) launch paths.
+
+Adapted from fermiviewer ``server_launch.py`` + ``netprobe.py`` (shared
+platform code — keep in sync). Split out of ``cli.py`` to respect the
+500-line god-module ceiling; ``main()``/arg parsing stay in cli.py and only
+its ``--dev`` / ``--desktop`` branches (plus the health-polled browser open
+on the default path) reach into this module.
+
+The probe helpers (``_health_ok``/``_bind``) are pure stdlib so importing
+this module stays cheap — uvicorn/pywebview are imported inside the launch
+functions that need them.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import socket as _socket
+
+__all__ = ["_open_when_healthy", "_resolve_port", "_run_desktop", "_run_dev"]
+
+# Built SPA — same resolution as quantized.app._WEB_DIR / cli._WEB_DIR.
+_WEB_DIR = Path(__file__).parent / "web"
+
+
+def _frontend_dir() -> Path:
+    """The repo-checkout ``frontend/`` (``--dev`` needs sources, not a build)."""
+    return Path(__file__).resolve().parents[2] / "frontend"
+
+
+def _health_ok(host: str, port: int, timeout: float = 0.4) -> bool:
+    """True iff a *quantized* server answers /api/health with ``status: ok`` —
+    tells our own instance apart from a foreign app on the port, and gates
+    the browser/window open on the server actually being up."""
+    import json
+    import urllib.request
+
+    try:
+        with urllib.request.urlopen(
+            f"http://{host}:{port}/api/health", timeout=timeout
+        ) as r:
+            if r.status != 200:
+                return False
+            data = json.loads(r.read())
+            return bool(isinstance(data, dict) and data.get("status") == "ok")
+    except Exception:
+        return False
+
+
+def _bind(host: str, port: int) -> _socket.socket | None:
+    """Bind + listen on host:port, returning the live socket, or None if the
+    port is taken. Binding up front turns a busy port into a value we can
+    branch on (reuse a healthy sibling, refuse a foreign app) instead of an
+    'address already in use' traceback; the socket is handed to
+    ``Server.run(sockets=[...])``, closing the check->bind race."""
+    import os
+    import socket
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        # SO_REUSEADDR everywhere EXCEPT Windows, where it acts like
+        # SO_REUSEPORT and would let us bind a port a foreign server owns.
+        if os.name != "nt":
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind((host, port))
+        s.listen()
+        return s
+    except OSError:
+        s.close()
+        return None
+
+
+def _resolve_port(host: str, port: int, *, explicit: bool) -> int:
+    """Return the port to actually bind: ``port`` unchanged if it's free (or
+    if the caller passed ``--port`` explicitly — an explicit port that's busy
+    still errors the same way it does today, via the caller's own bind /
+    ``uvicorn.run``). Otherwise (default port, busy — the main app is often
+    already running on 8000, MAIN_PLAN #22) probe for a free OS-assigned
+    ephemeral port and return that instead, printing a note so the user
+    knows where the server actually came up.
+
+    Skips the bind probe entirely when ``explicit`` is set, so passing an
+    explicit ``--port`` never touches a socket here.
+    """
+    if explicit:
+        return port
+
+    sock = _bind(host, port)
+    if sock is not None:
+        sock.close()
+        return port
+
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as free:
+        free.bind((host, 0))
+        fallback = int(free.getsockname()[1])
+    print(f"[qz] port {port} is busy - using {fallback} instead")
+    return fallback
+
+
+def _open_browser_later(url: str, delay: float = 2.0) -> None:
+    """Fixed-delay browser open — used only for the dev path, where the
+    target is the Vite server (no /api/health to poll)."""
+    import webbrowser
+
+    timer = threading.Timer(delay, webbrowser.open, [url])
+    timer.daemon = True  # don't keep the process alive on Ctrl+C in --dev
+    timer.start()
+
+
+def _open_when_healthy(url: str, host: str, port: int, timeout: float = 30.0) -> None:
+    """Open the browser only once the server answers — a fixed delay races a
+    cold numpy/scipy/matplotlib import and shows 'can't reach this page'.
+    Polls /api/health in a daemon thread; opens anyway after the timeout."""
+    import webbrowser
+
+    def _wait_then_open() -> None:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if _health_ok(host, port):
+                webbrowser.open(url)
+                return
+            time.sleep(0.25)
+        webbrowser.open(url)  # last resort: open anyway after the timeout
+
+    threading.Thread(target=_wait_then_open, daemon=True).start()
+
+
+_WEBVIEW_HINT = (
+    "--desktop needs pywebview: pip install quantized[desktop]\n"
+    "On Linux it also needs a native GUI backend (PyGObject + WebKitGTK, "
+    "e.g. `sudo apt install python3-gi gir1.2-webkit2-4.1`, or PyQt5/PySide2)."
+)
+
+
+def _run_desktop(
+    host: str,
+    port: int,
+    *,
+    title: str = "Quantized",
+    width: int = 1440,
+    height: int = 920,
+    path: str = "",
+) -> None:
+    """Native window: uvicorn in a thread, pywebview on top — pure Python, no
+    Rust toolchain (the Tauri shell in src-tauri/ is the packaged path).
+    Closing the window stops the server.
+
+    ``title``/``width``/``height``/``path`` let the ``--calc`` combo
+    (MAIN_PLAN #22) open a smaller window titled "DiraCulator" at
+    ``/?view=calc`` instead of the default full-app window; defaults are
+    the plain ``qz --desktop`` window unchanged."""
+    if not _WEB_DIR.is_dir():
+        print(
+            f"[qz] UI not built ({_WEB_DIR} missing). "
+            "Run: cd frontend && npm run build  (or use the run launcher)."
+        )
+        return
+
+    try:
+        import webview
+    except ImportError as e:
+        print(f"[qz] {_WEBVIEW_HINT}\n(import error: {e})")
+        return
+
+    import uvicorn
+
+    from quantized.app import app
+
+    # Bind up front so a taken port is a clean branch, not a crashed server
+    # thread: reuse our own healthy instance (point the window at it), or
+    # refuse a foreign app instead of hanging 30 s on a dead window.
+    sock = _bind(host, port)
+    server: uvicorn.Server | None = None
+    t: threading.Thread | None = None
+    if sock is None:
+        if not _health_ok(host, port):
+            print(f"[qz] port {port} is in use by another app - close it and retry")
+            return
+    else:
+        server = uvicorn.Server(
+            uvicorn.Config(app, host=host, port=port, log_level="warning")
+        )
+        s = sock  # bound socket handed to uvicorn — closes the bind race
+        t = threading.Thread(target=lambda: server.run(sockets=[s]), daemon=True)
+        t.start()
+
+    # Wait for the server to answer before pointing the window at it, else
+    # the webview shows a connection-refused page and never retries.
+    deadline = time.monotonic() + 30.0
+    while time.monotonic() < deadline and not _health_ok(host, port):
+        time.sleep(0.25)
+
+    try:
+        webview.create_window(
+            title,
+            f"http://{host}:{port}{path}",
+            width=width,
+            height=height,
+            background_color="#121116",  # dark --surface-0 (oklch 0.16 0.008 280)
+        )
+        webview.start()
+    except Exception as e:
+        print(f"[qz] {_WEBVIEW_HINT}\n(error: {e})")
+    finally:
+        if server is not None:
+            server.should_exit = True
+        if t is not None:
+            t.join(timeout=5)
+
+
+def _run_dev(host: str, port: int) -> None:
+    """Vite dev server (HMR) + auto-reloading uvicorn in one terminal."""
+    import os
+    import subprocess
+
+    import uvicorn
+
+    frontend = _frontend_dir()
+    if not frontend.is_dir():
+        print(f"[qz] --dev requires a source checkout; frontend/ not found at {frontend}")
+        raise SystemExit(2)
+    npm = "npm.cmd" if os.name == "nt" else "npm"
+    # Tell the Vite proxy which backend port to target (vite.config.ts reads
+    # QZ_BACKEND_PORT; review 2026-07-11: it was hardcoded to 8000, so
+    # `qz --dev --port 9000` silently proxied /api to the WRONG server).
+    env = dict(os.environ, QZ_BACKEND_PORT=str(port))
+    vite = subprocess.Popen([npm, "run", "dev"], cwd=frontend, env=env)
+    _open_browser_later("http://localhost:5173")
+    try:
+        uvicorn.run("quantized.app:app", host=host, port=port, reload=True)
+    finally:
+        # Windows: terminate() only kills the npm.cmd wrapper and orphans the
+        # node/Vite child holding :5173 (review 2026-07-11) - kill the tree.
+        if os.name == "nt":
+            subprocess.run(
+                ["taskkill", "/T", "/F", "/PID", str(vite.pid)],
+                capture_output=True,
+                check=False,
+            )
+        else:
+            vite.terminate()
+        try:
+            vite.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            pass  # never mask the real exit path from inside finally