spmkit 0.1.0__py3-none-any.whl

spmkit/__init__.py

@@ -0,0 +1,16 @@
+"""spmkit: analizador open-source de datos AFM/KPFM para SPM.
+
+API de conveniencia de nivel superior::
+
+    from spmkit import load
+    data = load("scan.nid")
+    ch = data["Z-Axis"]
+
+Para el análisis usa los submódulos de :mod:`spmkit.core.analysis`.
+"""
+
+from spmkit.core import SPMChannel, SPMData, load
+
+__version__ = "0.1.0"
+
+__all__ = ["load", "SPMData", "SPMChannel", "__version__"]

spmkit/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Capa CLI de spmkit (orquestación, sin lógica de análisis)."""
+
+from spmkit.cli.app import app
+
+__all__ = ["app"]

spmkit/cli/app.py

@@ -0,0 +1,233 @@
+"""Interfaz de línea de comandos de spmkit.
+
+Esta capa SOLO orquesta: parsea argumentos, llama al ``core`` y presenta
+resultados. No contiene lógica de análisis.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from spmkit import __version__, load
+from spmkit.core.analysis import kpfm, leveling, roughness
+from spmkit.core.export import to_csv, to_json
+
+app = typer.Typer(
+    name="spmkit",
+    help="Analizador open-source de datos AFM/KPFM (SPM Lab UTFSM).",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"spmkit {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    _version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Muestra la versión y sale.",
+    ),
+) -> None:
+    """spmkit: análisis de microscopía de sonda de barrido."""
+
+
+@app.command()
+def info(file: Path = typer.Argument(..., exists=True, help="Archivo .nid o .nhf")) -> None:
+    """Muestra metadatos y canales del archivo."""
+    data = load(file)
+    table = Table(title=f"{file.name}  ·  formato {data.metadata.get('format', '?')}")
+    table.add_column("Canal", style="cyan")
+    table.add_column("Dirección")
+    table.add_column("Forma")
+    table.add_column("Unidad")
+    table.add_column("Tamaño X·Y", justify="right")
+    for ch in data.channels:
+        table.add_row(
+            ch.name,
+            ch.direction,
+            f"{ch.shape[0]}×{ch.shape[1]}",
+            ch.unit,
+            f"{ch.x_range * 1e6:.2f}×{ch.y_range * 1e6:.2f} µm",
+        )
+    console.print(table)
+
+
+@app.command(name="roughness")
+def roughness_cmd(
+    file: Path = typer.Argument(..., exists=True, help="Archivo .nid o .nhf"),
+    channel: str = typer.Option("Z-Axis", "--channel", "-c", help="Canal a analizar"),
+    level: str = typer.Option("plane", "--level", "-l", help="Nivelación: plane|poly|none"),
+) -> None:
+    """Calcula parámetros de rugosidad (ISO 25178) de un canal."""
+    data = load(file)
+    ch = data[channel]
+    ch = _apply_level(ch, level)
+    result = roughness.statistics(ch)
+    table = Table(title=f"Rugosidad · {channel} ({result.unit})")
+    table.add_column("Parámetro", style="cyan")
+    table.add_column("Valor", justify="right")
+    for key, value in result.to_dict().items():
+        if isinstance(value, float):
+            table.add_row(key, f"{value:.4g}")
+        else:
+            table.add_row(key, str(value))
+    console.print(table)
+
+
+@app.command()
+def analyze(
+    file: Path = typer.Argument(..., exists=True, help="Archivo .nid o .nhf"),
+    output: Path = typer.Option(Path("./results"), "--output", "-o", help="Carpeta de salida"),
+    channel: str = typer.Option("Z-Axis", "--channel", "-c"),
+    cpd_channel: str = typer.Option("CPD", "--cpd-channel"),
+    level: str = typer.Option("plane", "--level", "-l"),
+    tip_work_function: float | None = typer.Option(
+        None, "--tip-wf", help="Función de trabajo de la punta (eV) para KPFM"
+    ),
+) -> None:
+    """Pipeline completo: rugosidad (+ KPFM si hay canal) → CSV + JSON."""
+    data = load(file)
+    output.mkdir(parents=True, exist_ok=True)
+    stem = file.stem
+
+    ch = _apply_level(data[channel], level)
+    rough = roughness.statistics(ch)
+    to_csv(rough, output / f"{stem}_roughness.csv")
+    to_json(rough, output / f"{stem}_roughness.json")
+    console.print(f"[green]✓[/] Rugosidad → {output / (stem + '_roughness.csv')}")
+
+    if cpd_channel in data.names:
+        cpd = kpfm.statistics(data[cpd_channel], tip_work_function=tip_work_function)
+        to_csv(cpd, output / f"{stem}_kpfm.csv")
+        to_json(cpd, output / f"{stem}_kpfm.json")
+        console.print(f"[green]✓[/] KPFM → {output / (stem + '_kpfm.csv')}")
+    else:
+        console.print(f"[yellow]·[/] Sin canal CPD ({cpd_channel!r}); se omite KPFM.")
+
+
+@app.command()
+def nanomech(
+    file: Path = typer.Argument(..., exists=True, help="Archivo .nid con espectroscopía"),
+    channel: str = typer.Option("Deflection", "--channel", "-c", help="Canal de fuerza (N)"),
+    curve: int = typer.Option(-1, "--curve", help="Índice de curva (-1 = la del medio)"),
+    tip_radius: float = typer.Option(10e-9, "--tip-radius", help="Radio de punta (m)"),
+    model: str = typer.Option("sphere", "--model", help="sphere|paraboloid|cone"),
+) -> None:
+    """Ajusta una curva fuerza-distancia (Hertz) y estima el módulo de Young."""
+    from spmkit.core.analysis import mechanics
+
+    data = load(file)
+    ch = data[channel]
+    curves = mechanics.extract_curves(ch)
+    if not curves:
+        console.print("[red]No se encontraron curvas en el canal.[/]")
+        raise typer.Exit(1)
+    idx = len(curves) // 2 if curve < 0 else curve
+    result = mechanics.fit_hertz(curves[idx], tip_radius=tip_radius, model=model)
+    table = Table(title=f"Nanomecánica · curva {idx}/{len(curves)} · {model}")
+    table.add_column("Parámetro", style="cyan")
+    table.add_column("Valor", justify="right")
+    table.add_row("Módulo de Young", f"{result.young_modulus / 1e6:.4g} MPa")
+    table.add_row("Punto de contacto", f"{result.contact_point * 1e9:.2f} nm")
+    table.add_row("Adhesión", f"{result.adhesion * 1e9:.3g} nN")
+    table.add_row("RMSE", f"{result.rmse:.3e}")
+    console.print(table)
+
+
+@app.command()
+def batch(
+    folder: Path = typer.Argument(..., exists=True, file_okay=False, help="Carpeta con archivos"),
+    channel: str = typer.Option("Z-Axis", "--channel", "-c"),
+    output: Path = typer.Option(Path("batch_summary.csv"), "--output", "-o"),
+) -> None:
+    """Procesa todos los archivos SPM de una carpeta → tabla resumen CSV."""
+    from spmkit.core import batch as batch_mod
+
+    files = batch_mod.find_files(folder)
+    if not files:
+        console.print("[yellow]No hay archivos SPM soportados en la carpeta.[/]")
+        raise typer.Exit(1)
+    result = batch_mod.process(files, channel=channel)
+    result.to_csv(output)
+    console.print(f"[green]✓[/] {result.n_ok} ok, {result.n_failed} con error → {output}")
+
+
+@app.command()
+def figure(
+    file: Path = typer.Argument(..., exists=True, help="Archivo .nid/.nhf/.gwy"),
+    channel: str = typer.Option("Z-Axis", "--channel", "-c"),
+    output: Path = typer.Option(Path("figure.png"), "--output", "-o", help="png|svg|pdf"),
+    colormap: str = typer.Option("batlow", "--colormap"),
+    title: str = typer.Option("", "--title"),
+) -> None:
+    """Exporta una figura de publicación (con scale bar y colormap científico)."""
+    from spmkit.core.viz import FigureSpec, save_figure
+
+    data = load(file)
+    ch = data[channel]
+    spec = FigureSpec(
+        title=title or ch.name, colormap=colormap, colorbar_label=f"{ch.name} ({ch.unit})"
+    )
+    save_figure(ch, spec, output)
+    console.print(f"[green]✓[/] Figura → {output}")
+
+
+@app.command()
+def convert(
+    file: Path = typer.Argument(..., exists=True, help="Archivo de entrada"),
+    output: Path = typer.Argument(..., help="Archivo de salida (.gwy o .h5)"),
+) -> None:
+    """Convierte entre formatos (p.ej. .nid → .gwy para abrir en Gwyddion)."""
+    data = load(file)
+    suffix = output.suffix.lower()
+    if suffix == ".gwy":
+        from spmkit.core.io import save_gwy
+
+        save_gwy(data, output)
+    elif suffix in (".h5", ".hdf5"):
+        from spmkit.core.export import to_hdf5
+
+        to_hdf5(data, output)
+    else:
+        raise typer.BadParameter("Formato de salida soportado: .gwy, .h5")
+    console.print(f"[green]✓[/] {file.name} → {output}")
+
+
+@app.command()
+def gui() -> None:
+    """Lanza la interfaz gráfica (requiere el extra 'gui')."""
+    try:
+        from spmkit.gui.app import run
+
+        run()
+    except ImportError:
+        console.print("[red]La GUI requiere PyQt6. Instala con:[/] pip install 'spmkit[gui]'")
+        raise typer.Exit(code=1) from None
+
+
+def _apply_level(ch, level: str):  # type: ignore[no-untyped-def]
+    if level == "plane":
+        return leveling.plane_fit(ch)
+    if level == "poly":
+        return leveling.polynomial(ch, order=2)
+    if level == "none":
+        return ch
+    raise typer.BadParameter("level debe ser plane|poly|none")
+
+
+if __name__ == "__main__":
+    app()

spmkit/core/__init__.py

@@ -0,0 +1,15 @@
+"""Backend de spmkit: puro Python, sin dependencias de UI.
+
+Reúne las cuatro sub-capas del núcleo:
+
+* :mod:`spmkit.core.io` — lectura de formatos (``.nid``, ``.nhf``)
+* :mod:`spmkit.core.models` — modelos de datos del dominio
+* :mod:`spmkit.core.analysis` — análisis numérico
+* :mod:`spmkit.core.export` — exportación a formatos abiertos
+"""
+
+from spmkit.core import analysis, batch, export, io, models, viz
+from spmkit.core.io import load
+from spmkit.core.models import SPMChannel, SPMData
+
+__all__ = ["io", "models", "analysis", "export", "viz", "batch", "load", "SPMData", "SPMChannel"]

spmkit/core/analysis/__init__.py

@@ -0,0 +1,21 @@
+"""Análisis numérico de datos SPM."""
+
+from spmkit.core.analysis import kpfm, leveling, mechanics, profiles, roughness
+from spmkit.core.analysis.kpfm import CPDResult
+from spmkit.core.analysis.mechanics import ForceCurve, IndentationResult, MechanicalMap
+from spmkit.core.analysis.profiles import Profile
+from spmkit.core.analysis.roughness import RoughnessResult
+
+__all__ = [
+    "leveling",
+    "roughness",
+    "profiles",
+    "kpfm",
+    "mechanics",
+    "RoughnessResult",
+    "Profile",
+    "CPDResult",
+    "ForceCurve",
+    "IndentationResult",
+    "MechanicalMap",
+]

spmkit/core/analysis/kpfm.py

@@ -0,0 +1,65 @@
+"""Análisis KPFM: potencial de contacto (CPD) y función de trabajo.
+
+En KPFM se mide la diferencia de potencial de contacto (CPD, *Contact
+Potential Difference*) entre la punta y la muestra::
+
+    V_CPD = (phi_tip - phi_sample) / e
+
+de donde la función de trabajo de la muestra es::
+
+    phi_sample = phi_tip - e * V_CPD
+
+Si se trabaja en eV y V_CPD en voltios, ``e * V_CPD`` (en eV) es
+numéricamente igual a ``V_CPD`` (en V).
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import numpy as np
+
+from spmkit.core.models import SPMChannel
+
+
+@dataclass(frozen=True)
+class CPDResult:
+    """Estadísticas del canal de potencial de contacto (CPD)."""
+
+    mean: float
+    std: float
+    minimum: float
+    maximum: float
+    contrast: float
+    unit: str
+    work_function: float | None = None
+    work_function_unit: str = "eV"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def statistics(channel: SPMChannel, tip_work_function: float | None = None) -> CPDResult:
+    """Estadísticas del canal CPD y, si se da ``tip_work_function``, la phi de la muestra.
+
+    Args:
+        channel: Canal de CPD/potencial (unidad típica ``V``).
+        tip_work_function: Función de trabajo de la punta en eV. Si se entrega,
+            se calcula ``phi_sample = phi_tip - V_CPD_medio``.
+    """
+    v = np.asarray(channel.data, dtype=np.float64).ravel()
+    v = v[np.isfinite(v)]
+    mean = float(v.mean())
+    work_function = None
+    if tip_work_function is not None:
+        work_function = float(tip_work_function - mean)
+
+    return CPDResult(
+        mean=mean,
+        std=float(v.std()),
+        minimum=float(v.min()),
+        maximum=float(v.max()),
+        contrast=float(v.max() - v.min()),
+        unit=channel.unit,
+        work_function=work_function,
+    )

spmkit/core/analysis/leveling.py

@@ -0,0 +1,61 @@
+"""Nivelación / corrección de fondo de imágenes SPM.
+
+La topografía cruda suele venir con inclinación (tilt) del piezo o del
+montaje de la muestra. Estas funciones la corrigen antes de calcular
+rugosidad o perfiles.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from spmkit.core.models import SPMChannel
+
+
+def plane_fit(channel: SPMChannel) -> SPMChannel:
+    """Resta un plano de mínimos cuadrados ``z = a*x + b*y + c``.
+
+    Es la corrección de inclinación más común para topografía AFM.
+    """
+    z = channel.data
+    rows, cols = z.shape
+    yy, xx = np.mgrid[0:rows, 0:cols]
+    a_mat = np.column_stack([xx.ravel(), yy.ravel(), np.ones(z.size)])
+    coeffs, *_ = np.linalg.lstsq(a_mat, z.ravel(), rcond=None)
+    plane = (a_mat @ coeffs).reshape(z.shape)
+    return channel.with_data(z - plane)
+
+
+def polynomial(channel: SPMChannel, order: int = 2) -> SPMChannel:
+    """Resta una superficie polinómica 2D de grado ``order``.
+
+    Útil cuando hay curvatura (bow) además de inclinación.
+    """
+    if order < 1:
+        raise ValueError("order debe ser >= 1")
+    z = channel.data
+    rows, cols = z.shape
+    yy, xx = np.mgrid[0:rows, 0:cols]
+    x = xx.ravel().astype(np.float64)
+    y = yy.ravel().astype(np.float64)
+    terms = [(x**i) * (y**j) for i in range(order + 1) for j in range(order + 1 - i)]
+    a_mat = np.column_stack(terms)
+    coeffs, *_ = np.linalg.lstsq(a_mat, z.ravel(), rcond=None)
+    surface = (a_mat @ coeffs).reshape(z.shape)
+    return channel.with_data(z - surface)
+
+
+def align_rows(channel: SPMChannel, method: str = "median") -> SPMChannel:
+    """Alinea filas restando su estadístico (corrige saltos línea a línea).
+
+    Args:
+        method: ``"median"`` (robusto) o ``"mean"``.
+    """
+    z = channel.data
+    if method == "median":
+        baseline = np.median(z, axis=1, keepdims=True)
+    elif method == "mean":
+        baseline = np.mean(z, axis=1, keepdims=True)
+    else:
+        raise ValueError("method debe ser 'median' o 'mean'")
+    return channel.with_data(z - baseline)

spmkit/core/analysis/mechanics.py

@@ -0,0 +1,272 @@
+"""Análisis de nanomecánica a partir de curvas fuerza-distancia (force-distance).
+
+Flujo típico:
+
+1. :func:`extract_curves` saca las curvas individuales de un canal de
+   espectroscopía (grupos ``Spec`` de NanoSurf: ``Lines`` curvas ×
+   ``Points`` muestras, con eje Z en ``Dim0`` y fuerza en ``Dim2``).
+2. :func:`baseline_correct` quita la línea base (zona sin contacto).
+3. :func:`find_contact_point` detecta el punto de contacto.
+4. :func:`fit_hertz` ajusta un modelo de contacto y estima el módulo de Young.
+
+Convención: ``z`` creciente acerca la punta a la muestra; el contacto ocurre
+a ``z`` alto. En el régimen de contacto, la indentación es
+``delta = (z - z0) - deflexión``; con cantiléver rígido o sin constante de
+resorte se aproxima ``delta ≈ z - z0``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+
+import numpy as np
+
+from spmkit.core.models import SPMChannel
+
+#: Modelos de contacto soportados y su exponente de indentación.
+_MODELS = {
+    "sphere": 1.5,  # Hertz esférico / paraboloide (R = radio de punta)
+    "paraboloid": 1.5,
+    "cone": 2.0,  # Sneddon cónico (alpha = semiángulo)
+}
+
+
+@dataclass(frozen=True)
+class ForceCurve:
+    """Una curva fuerza-distancia individual."""
+
+    z: np.ndarray
+    force: np.ndarray
+    index: int = 0
+    direction: str = "forward"
+    z_unit: str = "m"
+    force_unit: str = "N"
+    metadata: dict = field(default_factory=dict)
+
+    def __len__(self) -> int:
+        return int(self.z.size)
+
+
+@dataclass(frozen=True)
+class IndentationResult:
+    """Resultado del ajuste de una curva fuerza-indentación."""
+
+    young_modulus: float
+    contact_point: float
+    adhesion: float
+    model: str
+    rmse: float
+    unit_modulus: str = "Pa"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def extract_curves(channel: SPMChannel) -> list[ForceCurve]:
+    """Extrae las curvas fuerza-distancia de un canal de espectroscopía.
+
+    El eje Z se reconstruye de los metadatos ``Dim0Min``/``Dim0Range`` del
+    canal; la fuerza son los datos del canal (una curva por fila).
+    """
+    data = np.atleast_2d(np.asarray(channel.data, dtype=np.float64))
+    n_curves, n_points = data.shape
+    meta = channel.metadata
+    z_min = float(meta.get("Dim0Min", 0.0))
+    z_range = float(meta.get("Dim0Range", float(n_points)))
+    z = z_min + np.linspace(0.0, z_range, n_points)
+    z_unit = meta.get("Dim0Unit", "m")
+    return [
+        ForceCurve(
+            z=z,
+            force=data[i],
+            index=i,
+            direction=channel.direction,
+            z_unit=z_unit,
+            force_unit=channel.unit or "N",
+            metadata={"source_channel": channel.name},
+        )
+        for i in range(n_curves)
+    ]
+
+
+def baseline_correct(curve: ForceCurve, fraction: float = 0.3) -> ForceCurve:
+    """Resta la línea base ajustada a la zona sin contacto (``z`` bajo)."""
+    if not 0 < fraction < 1:
+        raise ValueError("fraction debe estar en (0, 1)")
+    n = max(2, int(curve.z.size * fraction))
+    coeffs = np.polyfit(curve.z[:n], curve.force[:n], 1)
+    baseline = np.polyval(coeffs, curve.z)
+    return ForceCurve(
+        z=curve.z,
+        force=curve.force - baseline,
+        index=curve.index,
+        direction=curve.direction,
+        z_unit=curve.z_unit,
+        force_unit=curve.force_unit,
+        metadata=dict(curve.metadata),
+    )
+
+
+def find_contact_point(curve: ForceCurve, fraction: float = 0.3, k: float = 5.0) -> float:
+    """Devuelve el ``z`` del punto de contacto (primer cruce sobre el ruido).
+
+    Usa la desviación estándar de la línea base como umbral (``k`` sigmas).
+    Asume que ``curve`` ya está corregida de base.
+    """
+    n = max(2, int(curve.z.size * fraction))
+    threshold = k * float(np.std(curve.force[:n]))
+    above = np.flatnonzero(curve.force > threshold)
+    if above.size == 0:
+        return float(curve.z[-1])
+    return float(curve.z[above[0]])
+
+
+def fit_hertz(
+    curve: ForceCurve,
+    tip_radius: float,
+    poisson: float = 0.3,
+    model: str = "sphere",
+    contact_point: float | None = None,
+    spring_constant: float | None = None,
+    half_angle: float = np.deg2rad(20.0),
+) -> IndentationResult:
+    """Ajusta un modelo de contacto a la curva y estima el módulo de Young.
+
+    * ``sphere``/``paraboloid``: ``F = (4/3) E* sqrt(R) delta^1.5``
+    * ``cone`` (Sneddon): ``F = (2/pi) E* tan(alpha) delta^2``
+
+    con ``E* = E / (1 - nu^2)``.
+
+    Args:
+        tip_radius: Radio de la punta ``R`` (m) para modelos esféricos.
+        poisson: Coeficiente de Poisson de la muestra.
+        model: ``"sphere"``, ``"paraboloid"`` o ``"cone"``.
+        contact_point: ``z0`` (m). Si es ``None`` se detecta automáticamente.
+        spring_constant: Constante del cantiléver (N/m) para corregir la
+            indentación por la deflexión. Si es ``None``, ``delta ≈ z - z0``.
+        half_angle: Semiángulo de la punta cónica (rad), solo para ``cone``.
+    """
+    if model not in _MODELS:
+        raise ValueError(f"model debe ser uno de {sorted(_MODELS)}")
+
+    corrected = baseline_correct(curve)
+    z0 = find_contact_point(corrected) if contact_point is None else contact_point
+
+    mask = corrected.z >= z0
+    z_c = corrected.z[mask]
+    f_c = corrected.force[mask]
+    if z_c.size < 3:
+        raise ValueError("Muy pocos puntos en contacto para ajustar")
+
+    delta = z_c - z0
+    if spring_constant is not None and spring_constant > 0:
+        delta = delta - f_c / spring_constant
+    valid = delta > 0
+    delta, f_c = delta[valid], f_c[valid]
+    if delta.size < 3:
+        raise ValueError("Indentación insuficiente tras la corrección")
+
+    exponent = _MODELS[model]
+    basis = delta**exponent
+    stiffness = float(np.sum(basis * f_c) / np.sum(basis**2))  # k tal que F = k·delta^n
+
+    e_star = _e_star_from_stiffness(stiffness, model, tip_radius, half_angle)
+    young = e_star * (1.0 - poisson**2)
+
+    predicted = stiffness * basis
+    rmse = float(np.sqrt(np.mean((f_c - predicted) ** 2)))
+
+    return IndentationResult(
+        young_modulus=young,
+        contact_point=float(z0),
+        adhesion=adhesion(curve),
+        model=model,
+        rmse=rmse,
+    )
+
+
+def adhesion(curve: ForceCurve) -> float:
+    """Fuerza de adhesión: magnitud del mínimo de fuerza (pull-off)."""
+    fmin = float(np.min(curve.force))
+    return -fmin if fmin < 0 else 0.0
+
+
+@dataclass(frozen=True)
+class MechanicalMap:
+    """Mapas de propiedades mecánicas a partir de un conjunto de curvas.
+
+    Cada arreglo tiene la forma de la grilla espacial (``rows × cols``); los
+    ajustes fallidos quedan como ``NaN``.
+    """
+
+    young_modulus: np.ndarray
+    adhesion: np.ndarray
+    contact_point: np.ndarray
+    grid_shape: tuple[int, int]
+    n_curves: int
+    n_failed: int
+    unit_modulus: str = "Pa"
+
+
+def _grid_shape(n: int, grid: tuple[int, int] | None) -> tuple[int, int]:
+    if grid is not None:
+        if grid[0] * grid[1] != n:
+            raise ValueError(f"grid {grid} no coincide con {n} curvas")
+        return grid
+    root = int(round(n**0.5))
+    if root * root == n:
+        return (root, root)
+    return (1, n)  # sin grilla cuadrada: tira 1×N
+
+
+def fit_all(
+    channel: SPMChannel,
+    tip_radius: float,
+    poisson: float = 0.3,
+    model: str = "sphere",
+    spring_constant: float | None = None,
+    grid: tuple[int, int] | None = None,
+) -> MechanicalMap:
+    """Ajusta todas las curvas de un canal y arma mapas de módulo y adhesión.
+
+    Args:
+        grid: Forma ``(rows, cols)`` de la grilla espacial. Si es ``None`` se
+            infiere una grilla cuadrada cuando es posible; si no, queda ``1×N``.
+    """
+    curves = extract_curves(channel)
+    n = len(curves)
+    shape = _grid_shape(n, grid)
+    young = np.full(n, np.nan)
+    adh = np.full(n, np.nan)
+    contact = np.full(n, np.nan)
+    n_failed = 0
+    for i, curve in enumerate(curves):
+        try:
+            r = fit_hertz(
+                curve,
+                tip_radius=tip_radius,
+                poisson=poisson,
+                model=model,
+                spring_constant=spring_constant,
+            )
+            young[i], adh[i], contact[i] = r.young_modulus, r.adhesion, r.contact_point
+        except (ValueError, ZeroDivisionError):
+            n_failed += 1
+    return MechanicalMap(
+        young_modulus=young.reshape(shape),
+        adhesion=adh.reshape(shape),
+        contact_point=contact.reshape(shape),
+        grid_shape=shape,
+        n_curves=n,
+        n_failed=n_failed,
+    )
+
+
+def _e_star_from_stiffness(
+    stiffness: float, model: str, tip_radius: float, half_angle: float
+) -> float:
+    """Despeja el módulo reducido E* de la rigidez ajustada ``F = k·delta^n``."""
+    if model in ("sphere", "paraboloid"):
+        return stiffness / ((4.0 / 3.0) * np.sqrt(tip_radius))
+    # cone (Sneddon)
+    return stiffness * np.pi / (2.0 * np.tan(half_angle))