specsr 1.0.2__py3-none-any.whl

specsr/__init__.py

@@ -0,0 +1,34 @@
+"""specsr — physics-informed deep learning for super-resolving galaxy spectra.
+
+Enhances low-resolution galaxy spectra by ~10x in resolving power (R~100 to
+R~1000), recovering narrow emission-line features — including blended doublets
+such as [O III] 4959,5007 and Hbeta — that are unresolvable at prism resolution.
+
+Trained on paired JWST/NIRSpec prism + medium-grating observations from JADES.
+"""
+
+from __future__ import annotations
+
+# Read from the installed metadata rather than restated here. A second copy of
+# the version drifts from pyproject.toml the first time one of them is bumped
+# alone -- which had already happened -- and the copy that is wrong is the one
+# users see.
+try:
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _version
+
+    __version__ = _version("specsr")
+except PackageNotFoundError:  # running from a source tree that was never installed
+    __version__ = "0.0.0.dev0"
+
+__all__ = ["__version__", "get_checkpoint"]
+
+
+def __getattr__(name: str):
+    # Lazy re-export keeps `import specsr` cheap: torch and huggingface_hub are
+    # only imported when a model or checkpoint is actually requested.
+    if name == "get_checkpoint":
+        from .checkpoints import get_checkpoint
+
+        return get_checkpoint
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

specsr/checkpoints.py

@@ -0,0 +1,125 @@
+"""On-demand model weight fetching from the Hugging Face Hub.
+
+Weights are not stored in the git repository. They live in a Hub model repo and
+are downloaded (and cached) the first time they are requested::
+
+    from specsr.checkpoints import get_checkpoint
+    path = get_checkpoint("sr1")
+
+Set ``SPECSR_CHECKPOINT_DIR`` to load from a local directory instead — useful
+during training, offline runs, or CI.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .paths import cache_dir
+
+__all__ = ["get_checkpoint", "available_checkpoints", "DEFAULT_REPO", "DEFAULT_REVISION"]
+
+DEFAULT_REPO = "aryana-haghjoo/specsr"
+
+# Pin the default revision so a fresh install reproduces published results even
+# if the Hub repo gains newer weights later. `v1-submission` is deliberately NOT
+# the default: it was trained on a leaky split (see the model card).
+DEFAULT_REVISION = "main"
+
+# Logical name -> path within the Hub repo.
+_REGISTRY: dict[str, str] = {
+    "sr1": "sr1/best_sr1.pth",
+    # SR1's architecture config. Registered rather than inferred: a Hub download
+    # places only the files actually requested into the snapshot directory, so
+    # looking for this one *beside* the downloaded weights finds nothing. That
+    # broke `from_pretrained()` for every public user while passing locally,
+    # where the archive directories do hold both files side by side.
+    "sr1_config": "sr1/config_logR.yaml",
+    "zhead": "zhead/best_zhead.pth",
+    "sr2": "sr2/best_sr2.pth",
+    # Redshift-comparison heads (LR / HR / SR2 inputs) used for the
+    # information-content diagnostic.
+    "zhead_lowres": "zhead/best_zhead_lowres.pth",
+    "zhead_hires": "zhead/best_zhead_hires.pth",
+    "zhead_sr2": "zhead/best_zhead_sr2.pth",
+}
+
+
+# What the training loops actually name their outputs. The Hub layout uses
+# tidier names, so a directory written by `specsr train` does not match the
+# registry path -- and `SPECSR_CHECKPOINT_DIR` is pointed at exactly such a
+# directory during training and offline work. Accept both.
+_LOCAL_ALIASES: dict[str, tuple[str, ...]] = {
+    "sr1": ("best_superres_model.pth", "final_model.pth"),
+    "sr1_config": ("config_logR.yaml",),
+    # `best_zhead.pth` is what the trainer writes since 2026-08-14; the
+    # suffixed name is kept so run directories written before that still load.
+    "zhead": ("best_zhead.pth", "best_zhead_sr1.pth"),
+    "sr2": ("best_sr2.pth",),
+    "zhead_lowres": ("best_zhead_lowres.pth",),
+    "zhead_hires": ("best_zhead_hires.pth",),
+    "zhead_sr2": ("best_zhead_sr2.pth",),
+}
+
+
+def available_checkpoints() -> list[str]:
+    """Logical checkpoint names understood by :func:`get_checkpoint`."""
+    return sorted(_REGISTRY)
+
+
+def get_checkpoint(
+    name: str,
+    repo_id: str | None = None,
+    revision: str | None = None,
+) -> Path:
+    """Return a local path to the requested checkpoint, downloading if needed.
+
+    Parameters
+    ----------
+    name
+        Logical name, e.g. ``"sr1"``. See :func:`available_checkpoints`.
+    repo_id
+        Override the Hub repo. Defaults to ``SPECSR_CHECKPOINT_REPO`` or
+        :data:`DEFAULT_REPO`.
+    revision
+        Branch, tag or commit. Defaults to ``SPECSR_CHECKPOINT_REVISION`` or
+        :data:`DEFAULT_REVISION`.
+    """
+    if name not in _REGISTRY:
+        raise KeyError(
+            f"Unknown checkpoint {name!r}. Available: {available_checkpoints()}"
+        )
+    filename = _REGISTRY[name]
+
+    # Local override wins: no network, no Hub account needed.
+    local_root = os.environ.get("SPECSR_CHECKPOINT_DIR")
+    if local_root:
+        root = Path(local_root).expanduser()
+        tried = [root / filename, root / Path(filename).name]
+        tried += [root / alias for alias in _LOCAL_ALIASES.get(name, ())]
+        for candidate in tried:
+            if candidate.exists():
+                return candidate
+        raise FileNotFoundError(
+            f"SPECSR_CHECKPOINT_DIR is set to {local_root!r} but none of these "
+            f"exist: {', '.join(str(t) for t in tried)}"
+        )
+
+    try:
+        from huggingface_hub import hf_hub_download
+    except ImportError as exc:  # pragma: no cover - depends on optional extra
+        raise ImportError(
+            "Downloading checkpoints requires huggingface_hub. Install it with "
+            "`pip install specsr[hub]`, or set SPECSR_CHECKPOINT_DIR to a local "
+            "directory of weights."
+        ) from exc
+
+    return Path(
+        hf_hub_download(
+            repo_id=repo_id or os.environ.get("SPECSR_CHECKPOINT_REPO", DEFAULT_REPO),
+            filename=filename,
+            revision=revision
+            or os.environ.get("SPECSR_CHECKPOINT_REVISION", DEFAULT_REVISION),
+            cache_dir=str(cache_dir() / "hub"),
+        )
+    )

specsr/cli.py

@@ -0,0 +1,158 @@
+"""Console entry point for specsr.
+
+Subcommands are dispatched lazily so that `specsr --help` stays fast and does
+not require the optional training or Hub dependencies to be installed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="specsr",
+        description="Super-resolve galaxy spectra with a physics-informed model.",
+    )
+    parser.add_argument("--version", action="version", version=f"specsr {__version__}")
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    p_build = sub.add_parser(
+        "build-dataset",
+        help="Build paired/augmented datasets from the raw JADES release tree.",
+    )
+    p_build.add_argument("--release", default="DR4", help="JADES release (default: DR4)")
+    p_build.add_argument("--out", default=None, help="Output .npz path")
+    p_build.add_argument(
+        "--n-aug", type=int, default=20, help="Augmented realizations per galaxy"
+    )
+    p_build.add_argument(
+        "--no-augment", action="store_true", help="Emit the unaugmented paired set only"
+    )
+    p_build.add_argument(
+        "--limit", type=int, default=None, help="Cap the number of galaxies (smoke tests)"
+    )
+
+    p_train = sub.add_parser("train", help="Train a pipeline stage.")
+    p_train.add_argument("stage", choices=["sr1", "zhead", "sr2"])
+    p_train.add_argument("--config", required=True, help="YAML config path")
+    p_train.add_argument("--dataset", default=None, help="Dataset .npz path")
+    p_train.add_argument("--out-dir", default=None, help="Where to write checkpoints")
+    p_train.add_argument(
+        "--source", choices=["lowres", "hires", "sr1", "sr2"], default=None,
+        help="zhead only: which spectrum representation the head sees. The "
+             "redshift comparison in the paper is this flag, four times.",
+    )
+    # Upstream stages are named explicitly rather than discovered, so a
+    # checkpoint always records the models it was trained on top of.
+    p_train.add_argument("--sr1-ckpt", default=None)
+    p_train.add_argument("--sr1-config", default=None)
+    p_train.add_argument("--zhead-ckpt", default=None)
+    p_train.add_argument("--sr2-ckpt", default=None)
+    p_train.add_argument("--zhead-bootstrap-ckpt", default=None,
+                         help="zhead --source sr2: the frozen head that conditions SR2")
+    p_train.add_argument("--init-ckpt", default=None,
+                         help="sr1/sr2: warm-start the stage's weights from this "
+                              "checkpoint for fine-tuning (architecture must match)")
+
+    p_infer = sub.add_parser("infer", help="Run the full pipeline on spectra.")
+    p_infer.add_argument("--dataset", required=True, help="Dataset .npz path")
+    p_infer.add_argument("--checkpoints", default=None,
+                         help="Directory holding best_superres_model.pth, "
+                              "config_logR.yaml, best_zhead.pth and best_sr2.pth")
+    p_infer.add_argument("--idx", type=int, nargs="+", help="Row indices")
+    p_infer.add_argument("--range", type=int, nargs=2, metavar=("START", "END"))
+    p_infer.add_argument("--save", default=None, help="Write outputs to this .npz")
+
+    p_eval = sub.add_parser("evaluate", help="Reproduce paper evaluations and figures.")
+    p_eval.add_argument(
+        "analysis",
+        choices=["all", "sample", "residuals", "line-flux", "line-snr",
+                 "augmentation", "coverage", "redshift"],
+    )
+    p_eval.add_argument("--dataset", default=None)
+    p_eval.add_argument("--cache", default=None,
+                        help="Prediction cache from scripts/make_predictions.py")
+    p_eval.add_argument("--outdir", default=None)
+    # The redshift figure's three arms are separate training runs.
+    p_eval.add_argument("--z-lowres", dest="z_lowres", default=None)
+    p_eval.add_argument("--z-hires", dest="z_hires", default=None)
+    p_eval.add_argument("--z-sr2", dest="z_sr2", default=None)
+
+    return parser
+
+
+def _parse_sweep_overrides(extras: list[str], parser: argparse.ArgumentParser) -> dict:
+    """Turn leftover ``--name=value`` arguments into config overrides.
+
+    A W&B sweep agent appends every searched parameter to the command this way
+    (the ``${args}`` macro), and the set of names is whatever that sweep
+    searches -- so they cannot be declared on the parser in advance. Before this
+    existed, ``specsr train`` rejected them outright and **every trial of every
+    sweep failed at argument parsing**, which is why no sweep in this repo had
+    ever run against the package CLI.
+
+    Values are parsed as YAML scalars so ``--lr=1e-4`` arrives as a float and
+    ``--use_var_clamp=true`` as a bool, rather than as strings that would then
+    be silently truthy.
+    """
+    import yaml
+
+    overrides: dict = {}
+    i = 0
+    while i < len(extras):
+        token = extras[i]
+        if not token.startswith("--"):
+            parser.error(f"unrecognized arguments: {token}")
+        name, sep, raw = token[2:].partition("=")
+        if not sep:
+            if i + 1 >= len(extras) or extras[i + 1].startswith("--"):
+                parser.error(f"override --{name} was given no value")
+            raw = extras[i + 1]
+            i += 1
+        overrides[name.replace("-", "_")] = yaml.safe_load(raw)
+        i += 1
+    return overrides
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args, extras = parser.parse_known_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 1
+
+    # Only `train` tolerates undeclared flags, and only because a sweep agent
+    # supplies them. Anywhere else an unrecognised flag is a typo and must stay
+    # an error rather than being quietly dropped.
+    if extras and args.command != "train":
+        parser.error(f"unrecognized arguments: {' '.join(extras)}")
+    args.overrides = _parse_sweep_overrides(extras, parser) if extras else {}
+
+    if args.command == "build-dataset":
+        from .data.build import run_build
+
+        return run_build(args)
+    if args.command == "train":
+        from .training.runner import run_train
+
+        return run_train(args)
+    if args.command == "infer":
+        from .inference.pipeline import run_infer
+
+        return run_infer(args)
+    if args.command == "evaluate":
+        from .evaluation.runner import run_evaluate
+
+        return run_evaluate(args)
+
+    parser.error(f"unhandled command {args.command!r}")
+    return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

specsr/config.py

@@ -0,0 +1,71 @@
+"""Configuration loading for the training stages.
+
+Configs come from two places and they do not look the same:
+
+- **Hand-written YAML**, a flat mapping of ``name: value``.
+- **Weights & Biases run dumps**, where every entry is wrapped as
+  ``name: {value: ...}`` and a ``_wandb`` key carries run metadata (host, GPU,
+  git commit, ...) that is not configuration at all.
+
+The shipped ``config.yaml`` files in this project are the second kind. Loading
+one naively gives every hyperparameter as the dict ``{"value": ...}``, so
+``float(cfg["lr"])`` raises and, worse, ``cfg.get("dropout", 0.1)`` silently
+returns a dict that some call sites will happily pass into a layer constructor.
+
+:func:`load_config` normalises both forms.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+__all__ = ["load_config", "unwrap_wandb_config", "merge_overrides"]
+
+#: Keys written by W&B run dumps that are metadata, not configuration.
+_WANDB_META_KEYS = {"_wandb", "_runtime", "_step", "_timestamp"}
+
+
+def unwrap_wandb_config(raw: dict[str, Any]) -> dict[str, Any]:
+    """Flatten a W&B-style ``{name: {value: ...}}`` mapping.
+
+    Entries that are not wrapped are passed through unchanged, so this is safe
+    to apply to a hand-written config too. W&B metadata keys are dropped.
+    """
+    out: dict[str, Any] = {}
+    for key, val in raw.items():
+        if key in _WANDB_META_KEYS:
+            continue
+        if isinstance(val, dict) and set(val.keys()) == {"value"}:
+            out[key] = val["value"]
+        else:
+            out[key] = val
+    return out
+
+
+def load_config(path: str | Path, **overrides: Any) -> dict[str, Any]:
+    """Load a YAML config, normalising W&B run dumps, then apply ``overrides``.
+
+    Overrides whose value is ``None`` are ignored, so argparse defaults can be
+    passed straight through without clobbering the file.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Config not found: {path}")
+
+    with path.open() as fh:
+        raw = yaml.safe_load(fh) or {}
+    if not isinstance(raw, dict):
+        raise TypeError(f"{path} must contain a mapping at the top level, got {type(raw).__name__}")
+
+    cfg = unwrap_wandb_config(raw)
+    return merge_overrides(cfg, **overrides)
+
+
+def merge_overrides(cfg: dict[str, Any], **overrides: Any) -> dict[str, Any]:
+    """Return ``cfg`` updated with the non-``None`` entries of ``overrides``."""
+    merged = dict(cfg)
+    merged.update({k: v for k, v in overrides.items() if v is not None})
+    return merged

specsr/data/__init__.py

@@ -0,0 +1,37 @@
+"""Dataset construction, loading and leak-free splitting.
+
+The preprocessing pipeline turns raw JADES products into paired ``.npz``
+datasets; :mod:`~specsr.data.datasets` loads them, and
+:mod:`~specsr.data.splits` splits them over parent galaxies rather than rows.
+"""
+
+from __future__ import annotations
+
+from .augment import AugmentationConfig, augment_pair
+from .build import BuildConfig, build_dataset
+from .datasets import FixedGridSpectraDataset, PairedSpectra, normalize_spectrum
+from .grid import DEFAULT_GRID, LogWavelengthGrid, resample_flux_conserving
+from .ingest import discover_spectra, group_by_target, read_spectrum
+from .splits import get_or_make_split, make_group_split, parent_group_ids
+from .stitch import StitchedSpectrum, stitch_gratings
+
+__all__ = [
+    "BuildConfig",
+    "build_dataset",
+    "AugmentationConfig",
+    "augment_pair",
+    "DEFAULT_GRID",
+    "LogWavelengthGrid",
+    "resample_flux_conserving",
+    "discover_spectra",
+    "group_by_target",
+    "read_spectrum",
+    "StitchedSpectrum",
+    "stitch_gratings",
+    "FixedGridSpectraDataset",
+    "PairedSpectra",
+    "normalize_spectrum",
+    "get_or_make_split",
+    "make_group_split",
+    "parent_group_ids",
+]

specsr/data/augment.py

@@ -0,0 +1,195 @@
+"""Augmentation of paired spectra, with explicit provenance.
+
+Each galaxy is expanded into one original plus ``n_aug`` stochastic realizations:
+a small Gaussian redshift offset, and flux perturbations scaled to the local
+flux. The intent is to teach robustness to line-position variability and to
+noise, rather than to add information.
+
+Provenance is not optional
+--------------------------
+Every emitted row records ``parent_id``, the index of the galaxy it came from.
+The original products did not: their ``id`` column was a running row index, so
+after augmentation there was no way to tell which rows shared a parent. Splitting
+then had to be reconstructed from ``(ra, dec, field)``, and any split drawn over
+rows put ~16 near-duplicate siblings of every held-out galaxy into training.
+
+Carrying ``parent_id`` makes the grouping explicit rather than inferred, so a
+leak-free split is the obvious thing to write rather than something that has to
+be recovered after the fact.
+
+Redshift shifts are translations on a log grid
+----------------------------------------------
+Because ``log(lambda * (1 + z)) = log(lambda) + log(1 + z)``, applying a redshift
+offset on a logarithmic wavelength grid is a *uniform shift* along the axis, the
+same number of samples at every wavelength. On the old linear grid the same
+operation stretched the spectrum, moving red features further than blue ones and
+changing the sampling of a line depending on where it sat.
+
+This also matches the model: the convolutional stages are translation
+equivariant, so an augmentation that is a pure translation exercises exactly the
+symmetry the architecture already has.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .grid import LogWavelengthGrid
+
+__all__ = ["AugmentationConfig", "shift_redshift_on_log_grid", "augment_pair"]
+
+
+@dataclass(frozen=True)
+class AugmentationConfig:
+    """Parameters of the augmentation.
+
+    Attributes
+    ----------
+    n_aug
+        Realizations generated per galaxy, in addition to the original.
+    sigma_z
+        Standard deviation of the Gaussian redshift offset.
+    noise_frac
+        Flux perturbation as a fraction of the local absolute flux.
+    seed
+        Base seed. Each galaxy derives its own generator from this and its
+        parent index, so a build is reproducible and adding galaxies does not
+        change the realizations of existing ones.
+    """
+
+    n_aug: int = 20
+    sigma_z: float = 0.3
+    noise_frac: float = 0.10
+    seed: int = 42
+
+
+def shift_redshift_on_log_grid(
+    flux: np.ndarray,
+    valid: np.ndarray,
+    z_from: float,
+    z_to: float,
+    grid: LogWavelengthGrid,
+    err: np.ndarray | None = None,
+):
+    """Move a spectrum from redshift ``z_from`` to ``z_to``.
+
+    On a log grid this is a shift of ``log((1 + z_to) / (1 + z_from))`` in
+    ``log lambda``, i.e. a constant number of samples. The shift is generally
+    fractional, so neighbouring samples are linearly combined; the validity mask
+    is shifted with the same weights and a sample is kept only if **both**
+    contributing samples were valid, so a shift cannot manufacture data at the
+    edge of a gap.
+
+    Samples shifted in from outside the grid are marked invalid rather than
+    wrapped or extrapolated: there is no measurement there.
+    """
+    n = flux.size
+    step = np.log(grid.lambda_max / grid.lambda_min) / (n - 1)
+    delta = np.log((1.0 + z_to) / (1.0 + z_from)) / step
+
+    lo = int(np.floor(delta))
+    frac = float(delta - lo)
+
+    def _shift(arr, fill):
+        out = np.full(n, fill, dtype=arr.dtype if arr.dtype != bool else arr.dtype)
+        src = np.arange(n) - lo
+        ok = (src >= 0) & (src < n)
+        out[ok] = arr[src[ok]]
+        return out, ok
+
+    a, ok_a = _shift(flux.astype(float), np.nan)
+    b, ok_b = _shift(np.roll(flux.astype(float), -1), np.nan)
+    va, _ = _shift(valid, False)
+    vb, _ = _shift(np.roll(valid, -1), False)
+
+    shifted = (1.0 - frac) * a + frac * b
+    # Both contributors must be real, or the interpolation invents flux.
+    shifted_valid = va & vb & ok_a & ok_b & np.isfinite(shifted)
+    shifted = np.where(shifted_valid, shifted, np.nan)
+
+    if err is None:
+        return shifted, shifted_valid
+
+    ea, _ = _shift(err.astype(float), np.nan)
+    eb, _ = _shift(np.roll(err.astype(float), -1), np.nan)
+    # Linear combination of independent samples -> quadrature with the weights.
+    shifted_err = np.sqrt(((1.0 - frac) * ea) ** 2 + (frac * eb) ** 2)
+    shifted_err = np.where(shifted_valid, shifted_err, np.nan)
+    return shifted, shifted_valid, shifted_err
+
+
+def augment_pair(
+    flux_low: np.ndarray,
+    flux_low_err: np.ndarray,
+    valid_low: np.ndarray,
+    flux_high: np.ndarray,
+    flux_high_err: np.ndarray,
+    valid_high: np.ndarray,
+    z: float,
+    parent_id: int,
+    grid: LogWavelengthGrid,
+    config: AugmentationConfig | None = None,
+) -> list[dict]:
+    """Expand one galaxy into ``1 + n_aug`` rows.
+
+    The first row is the unmodified original. Each subsequent row applies the
+    *same* redshift offset to both members of the pair — they are the same
+    galaxy, so a shift that moved them differently would teach the model a
+    wavelength mapping that does not exist — and independent noise to each, since
+    their measurement noise is genuinely independent.
+
+    Returns a list of dicts, each carrying ``parent_id`` and the realized ``z``.
+    """
+    config = config or AugmentationConfig()
+    rng = np.random.default_rng([config.seed, parent_id])
+
+    rows = [
+        {
+            "flux_low": np.asarray(flux_low, dtype=float),
+            "flux_low_err": np.asarray(flux_low_err, dtype=float),
+            "valid_low": np.asarray(valid_low, dtype=bool),
+            "flux_high": np.asarray(flux_high, dtype=float),
+            "flux_high_err": np.asarray(flux_high_err, dtype=float),
+            "valid_high": np.asarray(valid_high, dtype=bool),
+            "z": float(z),
+            "parent_id": int(parent_id),
+            "is_original": True,
+        }
+    ]
+
+    for _ in range(config.n_aug):
+        z_new = float(z + rng.normal(0.0, config.sigma_z))
+        # Negative redshift is unphysical and would invert the shift direction.
+        z_new = max(z_new, 0.0)
+
+        lo_f, lo_v, lo_e = shift_redshift_on_log_grid(
+            flux_low, valid_low, z, z_new, grid, err=flux_low_err
+        )
+        hi_f, hi_v, hi_e = shift_redshift_on_log_grid(
+            flux_high, valid_high, z, z_new, grid, err=flux_high_err
+        )
+
+        for f, e, v in ((lo_f, lo_e, lo_v), (hi_f, hi_e, hi_v)):
+            sigma = config.noise_frac * np.abs(np.nan_to_num(f))
+            noise = rng.normal(0.0, np.where(sigma > 0, sigma, 1e-30))
+            f[v] += noise[v]
+            # The added noise is part of the uncertainty budget from here on.
+            e[v] = np.sqrt(np.nan_to_num(e[v]) ** 2 + sigma[v] ** 2)
+
+        rows.append(
+            {
+                "flux_low": lo_f,
+                "flux_low_err": lo_e,
+                "valid_low": lo_v,
+                "flux_high": hi_f,
+                "flux_high_err": hi_e,
+                "valid_high": hi_v,
+                "z": z_new,
+                "parent_id": int(parent_id),
+                "is_original": False,
+            }
+        )
+
+    return rows