aspcap 0.2.0__tar.gz

aspcap-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Nidever
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aspcap-0.2.0/LICENSE-DOPPLER

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 David Nidever
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aspcap-0.2.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE-DOPPLER
+include README.md
+recursive-include docs *.rst *.py *.txt
+recursive-include examples *.py *.dat *.csv *.json

aspcap-0.2.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: aspcap
+Version: 0.2.0
+Summary: Element abundance fits with FERRE
+Author: David Nidever
+License: MIT License
+        
+        Copyright (c) 2026 David Nidever
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Documentation, https://aspcap.readthedocs.io/
+Project-URL: Repository, https://github.com/dnidever/aspcap
+Project-URL: Issues, https://github.com/dnidever/aspcap/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE-DOPPLER
+Requires-Dist: numpy>=1.23
+Requires-Dist: scipy>=1.9
+Dynamic: license-file
+
+# aspcap
+
+ASPCAP provides multi-order spectral data objects, external continuum
+normalization, and element-abundance fitting with FERRE for HGE.
+
+- [Spec1D objects](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst): single or multiple orders, unequal chip
+  lengths, masks, uncertainties, copying, and native-grid mapping.
+- [External continuum normalization](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst): polynomial, spline,
+  median, percentile, and model-ratio methods with diagnostics.
+- [FERRE abundance fitting](https://github.com/dnidever/aspcap/blob/main/docs/quickstart.rst): fit an element using fixed
+  global parameters and a supplied continuum.
+
+Install the latest release from PyPI with:
+
+```sh
+python -m pip install --upgrade aspcap
+```
+
+The spectrum and continuum modules do not need a FERRE executable or Doppler
+model files. Install [FERRE](https://github.com/dnidever/ferre) separately when
+running spectral fits: `python -m pip install --upgrade ferre`.
+
+## Try the worked example
+
+Install Python 3.9 or later and [FERRE](https://github.com/dnidever/ferre).
+The example was verified with FERRE 5.1.3. From the repository checkout, run:
+
+```sh
+python -m pip install -e .
+aspcap abundances examples/one-star.json --output abundance.csv --pixels pixels.csv
+```
+
+If `ferre` is outside your PATH, add `--ferre /path/to/ferre`. The example
+uses a synthetic spectrum and a toy grid. Expect a raw `ALPHA` coordinate of
+about 0.20 and a reported `[Mg/H]` of about −0.05, using four pixels and fixed
+`METALS = -0.25`. The pixel CSV shows the normalized flux, uncertainty, model,
+and whether each pixel was used. Add `--keep-runs` to inspect FERRE's input
+files after a successful fit. A failed fit keeps its files and reports their
+location.
+
+## Run your own fit
+
+1. Copy [one-star.json](https://github.com/dnidever/aspcap/blob/main/examples/one-star.json) and point it to your inputs.
+   Relative paths are resolved from the configuration file. Supply the global
+   fit as a dictionary with one starting value per grid label.
+2. Supply a spectrum CSV with `wavelength,flux,error,continuum` columns. The
+   spectrum must already be on the native rest-frame grid in the library's
+   wavelength units and air/vacuum convention. Give flux and one-sigma error
+   in the same units as the positive global continuum. The wrapper divides
+   both by that continuum and holds it fixed during the fit.
+3. Copy [mg.json](https://github.com/dnidever/aspcap/blob/main/examples/mg.json) and set the species, the one free grid label,
+   and one or more inclusive wavelength windows. Overlapping windows still
+   give each pixel weight one. Nonfinite flux and nonpositive or nonfinite
+   uncertainties get zero weight. Use `add_labels` to list any fixed logarithmic
+   coordinates to add to the fitted coordinate to report `[X/H]`. Leave it empty
+   if the fitted coordinate is already `[X/H]`. Verify this mapping and the
+   wavelength windows against the scientific conventions of your grid.
+
+This version supports single-segment, non-PCA FERRE libraries with a positive
+spectral resolution, either formatted ASCII or matching `.hdr` and `.unf`
+files. Point `grid` to the ASCII library or to the binary library's `.hdr`.
+The fit uses linear interpolation. The reported error is conditional on the
+fixed global parameters and continuum. The reduced χ² column comes from FERRE.
+
+## Use from Python
+
+```python
+from aspcap import Grid, fit_abundance
+
+grid = Grid.read("examples/toy-grid.dat")
+result, pixels = fit_abundance(
+    grid, wavelength, flux, error, continuum,
+    {"ALPHA": 0.0, "METALS": -0.25},
+    star_id="my-star", species="Mg", label="ALPHA",
+    windows=[(15002, 15005)], add_labels=["METALS"],
+)
+```
+
+Pass the four CSV columns as sequences. `result` is a dictionary and `pixels`
+iterates over the diagnostic rows.
+
+The FERRE protocol lives in `aspcap/ferre.py`, the abundance logic in
+`aspcap/abundances.py`, and file input and output in `aspcap/cli.py`. Run
+`python -m unittest discover -s tests -v` for the tests. Set
+`ASPCAP_TEST_FERRE=/path/to/ferre` to include the integration test if FERRE
+is outside your PATH.
+
+## Documentation
+
+The [user guide](https://github.com/dnidever/aspcap/blob/main/docs/index.rst) includes a quickstart, input reference,
+[Spec1D guide](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst), [continuum methods](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst), and
+Python API. The repository includes Read the Docs build configuration. To
+preview the guide locally after installing ASPCAP:
+
+```sh
+python -m pip install -r docs/requirements.txt
+python -m sphinx -W -b html docs docs/_build/html
+```
+
+
+The full-wavelength APOGEE DR17 M-giant test grid and detector weights are
+included in ASPCAP installations.
+
+```sh
+python -m pip install --upgrade aspcap
+```
+
+See the [Grid walkthrough](https://github.com/dnidever/aspcap/blob/main/docs/grid.rst#fit-the-full-apogee-dr17-wavelength-grid)
+for an example using the installed files.
+
+
+## Multi-order spectra and external continuum fitting
+
+`Spec1D` follows Doppler's `(pixels, orders)` layout, accepts unequal-length
+orders, preserves masks/metadata, and can map detector chips back to a native
+wavelength grid. It imports no Doppler fitting code or model loaders. Existing
+Doppler objects can be used directly with the continuum functions.
+
+```python
+from aspcap import Spec1D, continuum
+
+spec = Spec1D(flux_orders, wave=wavelength_orders, err=error_orders)
+result = continuum.fit(spec, method="chebyshev", degree=4)
+normalized = result.apply(spec)  # independent copy
+```
+
+Choose the estimator with `continuum.fit(spec, method=...)`:
+
+| Method | Useful options | Defaults |
+|---|---|---|
+| `chebyshev` / `polynomial` | `degree`, `weighted`, `clip` | Degree 4, unweighted, no clipping |
+| `spline` | `degree`, `smoothing`, `weighted`, `clip` | Degree 3, noise-based smoothing |
+| `median` | `window`, `mode` | 151 pixels, mirror edges |
+| `percentile` | `percentile`, `bins` | 90th percentile, 20 bins |
+| `model_ratio` | `model`, `window`, `ratio_bounds`, `mode` | Model required; 151 pixels; ratios 0.1–10 |
+
+Methods operate independently per order. Use `result.fit_mask`, `result.flags`,
+`result.parameters`, and `result.settings` to inspect the estimate. Invalid
+orders raise an error by default; `on_failure="mask"` returns flagged, masked
+results instead. `result.apply(spec)` returns a copy; `inplace=True` updates the
+input explicitly. All normalization here is outside FERRE. Applying a
+continuum rescales both flux and error; it does not include uncertainty in the
+continuum estimate. See [the spectrum guide](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst),
+[the continuum guide](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst), and the runnable
+[example](https://github.com/dnidever/aspcap/blob/main/examples/spectrum_continuum.py). The core design is adapted from
+[Doppler Spec1D](https://github.com/dnidever/doppler/blob/6e165f87c6d766eff6eaa1fbee2c82be5bb30cc0/doppler/spec1d.py);
+its MIT notice is retained in `LICENSE-DOPPLER`.

aspcap-0.2.0/README.md

@@ -0,0 +1,147 @@
+# aspcap
+
+ASPCAP provides multi-order spectral data objects, external continuum
+normalization, and element-abundance fitting with FERRE for HGE.
+
+- [Spec1D objects](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst): single or multiple orders, unequal chip
+  lengths, masks, uncertainties, copying, and native-grid mapping.
+- [External continuum normalization](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst): polynomial, spline,
+  median, percentile, and model-ratio methods with diagnostics.
+- [FERRE abundance fitting](https://github.com/dnidever/aspcap/blob/main/docs/quickstart.rst): fit an element using fixed
+  global parameters and a supplied continuum.
+
+Install the latest release from PyPI with:
+
+```sh
+python -m pip install --upgrade aspcap
+```
+
+The spectrum and continuum modules do not need a FERRE executable or Doppler
+model files. Install [FERRE](https://github.com/dnidever/ferre) separately when
+running spectral fits: `python -m pip install --upgrade ferre`.
+
+## Try the worked example
+
+Install Python 3.9 or later and [FERRE](https://github.com/dnidever/ferre).
+The example was verified with FERRE 5.1.3. From the repository checkout, run:
+
+```sh
+python -m pip install -e .
+aspcap abundances examples/one-star.json --output abundance.csv --pixels pixels.csv
+```
+
+If `ferre` is outside your PATH, add `--ferre /path/to/ferre`. The example
+uses a synthetic spectrum and a toy grid. Expect a raw `ALPHA` coordinate of
+about 0.20 and a reported `[Mg/H]` of about −0.05, using four pixels and fixed
+`METALS = -0.25`. The pixel CSV shows the normalized flux, uncertainty, model,
+and whether each pixel was used. Add `--keep-runs` to inspect FERRE's input
+files after a successful fit. A failed fit keeps its files and reports their
+location.
+
+## Run your own fit
+
+1. Copy [one-star.json](https://github.com/dnidever/aspcap/blob/main/examples/one-star.json) and point it to your inputs.
+   Relative paths are resolved from the configuration file. Supply the global
+   fit as a dictionary with one starting value per grid label.
+2. Supply a spectrum CSV with `wavelength,flux,error,continuum` columns. The
+   spectrum must already be on the native rest-frame grid in the library's
+   wavelength units and air/vacuum convention. Give flux and one-sigma error
+   in the same units as the positive global continuum. The wrapper divides
+   both by that continuum and holds it fixed during the fit.
+3. Copy [mg.json](https://github.com/dnidever/aspcap/blob/main/examples/mg.json) and set the species, the one free grid label,
+   and one or more inclusive wavelength windows. Overlapping windows still
+   give each pixel weight one. Nonfinite flux and nonpositive or nonfinite
+   uncertainties get zero weight. Use `add_labels` to list any fixed logarithmic
+   coordinates to add to the fitted coordinate to report `[X/H]`. Leave it empty
+   if the fitted coordinate is already `[X/H]`. Verify this mapping and the
+   wavelength windows against the scientific conventions of your grid.
+
+This version supports single-segment, non-PCA FERRE libraries with a positive
+spectral resolution, either formatted ASCII or matching `.hdr` and `.unf`
+files. Point `grid` to the ASCII library or to the binary library's `.hdr`.
+The fit uses linear interpolation. The reported error is conditional on the
+fixed global parameters and continuum. The reduced χ² column comes from FERRE.
+
+## Use from Python
+
+```python
+from aspcap import Grid, fit_abundance
+
+grid = Grid.read("examples/toy-grid.dat")
+result, pixels = fit_abundance(
+    grid, wavelength, flux, error, continuum,
+    {"ALPHA": 0.0, "METALS": -0.25},
+    star_id="my-star", species="Mg", label="ALPHA",
+    windows=[(15002, 15005)], add_labels=["METALS"],
+)
+```
+
+Pass the four CSV columns as sequences. `result` is a dictionary and `pixels`
+iterates over the diagnostic rows.
+
+The FERRE protocol lives in `aspcap/ferre.py`, the abundance logic in
+`aspcap/abundances.py`, and file input and output in `aspcap/cli.py`. Run
+`python -m unittest discover -s tests -v` for the tests. Set
+`ASPCAP_TEST_FERRE=/path/to/ferre` to include the integration test if FERRE
+is outside your PATH.
+
+## Documentation
+
+The [user guide](https://github.com/dnidever/aspcap/blob/main/docs/index.rst) includes a quickstart, input reference,
+[Spec1D guide](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst), [continuum methods](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst), and
+Python API. The repository includes Read the Docs build configuration. To
+preview the guide locally after installing ASPCAP:
+
+```sh
+python -m pip install -r docs/requirements.txt
+python -m sphinx -W -b html docs docs/_build/html
+```
+
+
+The full-wavelength APOGEE DR17 M-giant test grid and detector weights are
+included in ASPCAP installations.
+
+```sh
+python -m pip install --upgrade aspcap
+```
+
+See the [Grid walkthrough](https://github.com/dnidever/aspcap/blob/main/docs/grid.rst#fit-the-full-apogee-dr17-wavelength-grid)
+for an example using the installed files.
+
+
+## Multi-order spectra and external continuum fitting
+
+`Spec1D` follows Doppler's `(pixels, orders)` layout, accepts unequal-length
+orders, preserves masks/metadata, and can map detector chips back to a native
+wavelength grid. It imports no Doppler fitting code or model loaders. Existing
+Doppler objects can be used directly with the continuum functions.
+
+```python
+from aspcap import Spec1D, continuum
+
+spec = Spec1D(flux_orders, wave=wavelength_orders, err=error_orders)
+result = continuum.fit(spec, method="chebyshev", degree=4)
+normalized = result.apply(spec)  # independent copy
+```
+
+Choose the estimator with `continuum.fit(spec, method=...)`:
+
+| Method | Useful options | Defaults |
+|---|---|---|
+| `chebyshev` / `polynomial` | `degree`, `weighted`, `clip` | Degree 4, unweighted, no clipping |
+| `spline` | `degree`, `smoothing`, `weighted`, `clip` | Degree 3, noise-based smoothing |
+| `median` | `window`, `mode` | 151 pixels, mirror edges |
+| `percentile` | `percentile`, `bins` | 90th percentile, 20 bins |
+| `model_ratio` | `model`, `window`, `ratio_bounds`, `mode` | Model required; 151 pixels; ratios 0.1–10 |
+
+Methods operate independently per order. Use `result.fit_mask`, `result.flags`,
+`result.parameters`, and `result.settings` to inspect the estimate. Invalid
+orders raise an error by default; `on_failure="mask"` returns flagged, masked
+results instead. `result.apply(spec)` returns a copy; `inplace=True` updates the
+input explicitly. All normalization here is outside FERRE. Applying a
+continuum rescales both flux and error; it does not include uncertainty in the
+continuum estimate. See [the spectrum guide](https://github.com/dnidever/aspcap/blob/main/docs/spectrum.rst),
+[the continuum guide](https://github.com/dnidever/aspcap/blob/main/docs/continuum.rst), and the runnable
+[example](https://github.com/dnidever/aspcap/blob/main/examples/spectrum_continuum.py). The core design is adapted from
+[Doppler Spec1D](https://github.com/dnidever/doppler/blob/6e165f87c6d766eff6eaa1fbee2c82be5bb30cc0/doppler/spec1d.py);
+its MIT notice is retained in `LICENSE-DOPPLER`.

aspcap-0.2.0/aspcap/__init__.py

@@ -0,0 +1,8 @@
+"""Spectral data, external continuum normalization, and FERRE abundance fits."""
+
+from .abundances import fit_abundance
+from .ferre import Grid
+from .spectrum import Spec1D
+from . import continuum
+
+__all__ = ["Grid", "fit_abundance", "Spec1D", "continuum"]

aspcap-0.2.0/aspcap/abundances.py

@@ -0,0 +1,73 @@
+"""Fit an individual species using the continuum and labels of a global fit."""
+
+from math import isclose, isfinite
+import numpy as np
+from .ferre import run_ferre
+
+
+def fit_abundance(grid, wavelength, flux, error, continuum, parameters, *,
+                  star_id, species, label, windows, add_labels=(),
+                  executable="ferre", keep_runs=False, run_root=None, mask=None):
+    """Return a result row and a model on the native grid.
+
+    Inputs are in the grid's wavelength units and air/vacuum convention.
+    The optional mask uses True for unusable pixels.
+    Windows are inclusive (lower, upper) pairs with unit weights. The optional
+    add_labels are fixed global-fit coordinates added to report [X/H].
+    """
+    npix = len(grid.wavelengths)
+    badmask = np.zeros(npix, bool) if mask is None else np.asarray(mask, dtype=bool)
+    if badmask.shape != (npix,):
+        raise ValueError("mask must have one Boolean value per grid pixel (True means bad)")
+    if any(len(values) != npix for values in (wavelength, flux, error, continuum)):
+        raise ValueError("Spectrum and continuum must have one row per grid pixel")
+    if not all(isclose(a, b, rel_tol=0, abs_tol=1e-4 * (grid.wavelengths[1] - grid.wavelengths[0]))
+               for a, b in zip(wavelength, grid.wavelengths)):
+        raise ValueError("Spectrum wavelengths do not match the native grid")
+    if label not in grid.labels:
+        raise ValueError(f"Unknown abundance label {label!r}. Available: {grid.labels}")
+    if (label in add_labels or len(set(add_labels)) != len(add_labels)
+            or any(name not in parameters or name not in grid.labels for name in add_labels)):
+        raise ValueError("Abundance conversion labels must be distinct fixed grid labels")
+    if not windows or any(not (isfinite(lo) and isfinite(hi) and lo <= hi)
+                          for lo, hi in windows):
+        raise ValueError("Provide one or more finite wavelength windows (lower, upper)")
+
+    normalized_flux, normalized_error, weights = [], [], []
+    for wave, value, sigma, scale, bad in zip(wavelength, flux, error, continuum, badmask):
+        if not isfinite(scale) or scale <= 0:
+            raise ValueError("Global continuum values must be finite and positive")
+        value, sigma = value / scale, sigma / scale
+        good = not bad and isfinite(value) and isfinite(sigma) and sigma > 0
+        normalized_flux.append(value if good else 1.0)
+        normalized_error.append(sigma if good else 1e10)
+        weights.append(int(good and any(lo <= wave <= hi for lo, hi in windows)))
+    pixels_used = sum(weights)
+    if pixels_used < 2:
+        raise ValueError(f"{species}: fewer than two usable pixels in the element windows")
+
+    fit = run_ferre(grid, normalized_flux, normalized_error, parameters, label, weights,
+                    executable=executable, keep_runs=keep_runs, run_root=run_root)
+    axis = grid.labels.index(label)
+    raw = fit.parameters[label]
+    low, step = grid.lower[axis], grid.step[axis]
+    high = low + (grid.counts[axis] - 1) * step
+    flags = []
+    if min(raw - low, high - raw) <= 0.125 * step:
+        flags.append("GRID_EDGE")
+    if fit.errors[label] is None:
+        flags.append("NO_UNCERTAINTY")
+    result = {
+        "star_id": star_id,
+        "species": species,
+        "grid_label": label,
+        "raw_value": raw,
+        "abundance_scale": f"[{species}/H]",
+        "abundance": raw + sum(parameters[name] for name in add_labels),
+        "conditional_error": fit.errors[label],
+        "ferre_reduced_chi2": fit.reduced_chi2,
+        "pixels_used": pixels_used,
+        "flags": "|".join(flags),
+    }
+    pixels = zip(wavelength, normalized_flux, normalized_error, fit.model, weights)
+    return result, pixels

aspcap-0.2.0/aspcap/cli.py

@@ -0,0 +1,64 @@
+"""Command-line interface for a single HGE abundance fit."""
+
+import argparse
+import csv
+import json
+from pathlib import Path
+
+from . import Grid, fit_abundance
+
+
+def _run(args):
+    path = args.config.resolve()
+    config = json.loads(path.read_text())
+    species = json.loads((path.parent / config["species_file"]).read_text())
+    grid = Grid.read(path.parent / config["grid"])
+    expected_frame = "vacuum" if grid.vacuum else "air"
+    if config["wavelength_frame"] != expected_frame:
+        raise ValueError(f"Grid uses {expected_frame} wavelengths")
+    with (path.parent / config["spectrum"]).open(newline="") as file:
+        rows = list(csv.DictReader(file))
+    columns = [[float(row[name]) for row in rows]
+               for name in ("wavelength", "flux", "error", "continuum")]
+    executable = args.ferre or config.get("ferre", "ferre")
+    if not args.ferre and "/" in executable:
+        executable = path.parent / executable
+    result, pixels = fit_abundance(
+        grid, *columns, config["parameters"], star_id=config["star_id"],
+        species=species["species"], label=species["label"], windows=species["windows"],
+        add_labels=species.get("add_labels", ()), executable=executable,
+        keep_runs=args.keep_runs, run_root=args.run_root,
+    )
+    if args.pixels:
+        with args.pixels.open("w", newline="") as file:
+            writer = csv.writer(file)
+            writer.writerow(("wavelength", "normalized_flux", "normalized_error", "model", "weight"))
+            writer.writerows(pixels)
+    with args.output.open("w", newline="") as file:
+        writer = csv.DictWriter(file, fieldnames=result)
+        writer.writeheader()
+        writer.writerow(result)
+    print(f"Wrote {args.output}")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="aspcap", description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    abundances = commands.add_parser("abundances", help="fit an individual species")
+    abundances.add_argument("config", type=Path)
+    abundances.add_argument("--ferre", help="FERRE executable name or path")
+    abundances.add_argument("--output", type=Path, default=Path("abundance.csv"))
+    abundances.add_argument("--pixels", type=Path, help="save normalized data, model, and weights")
+    abundances.add_argument("--keep-runs", action="store_true")
+    abundances.add_argument("--run-root", type=Path, help="existing directory for FERRE run files")
+    args = parser.parse_args()
+    try:
+        if args.pixels and args.pixels.resolve() == args.output.resolve():
+            raise ValueError("--pixels and --output must use different files")
+        _run(args)
+    except (OSError, ValueError, KeyError, TypeError, RuntimeError) as error:
+        parser.exit(1, f"aspcap: {error}\n")
+
+
+if __name__ == "__main__":
+    main()