sed-model 0.3.2__tar.gz → 0.4.0__tar.gz

{sed_model-0.3.2 → sed_model-0.4.0}/CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## [0.4.0] — 2026-10-25
+
+Validated against the MESA `colors` module, MSG and MIST (see
+[Testing and Validation](docs/testing.md)); forward parity fixes and a rebuilt
+inverse model.
+
+### Forward model
+
+Forward-model parity fixes found by sweeping against MESA `colors` (see
+`tests/test_kernels.py`). SEDs and magnitudes otherwise agree with MESA to
+rounding error.
+
+- **`bol_mag` is `99.0` when the integrated flux is not positive** (MESA's
+  value), instead of `-99.9`.
+- **`nearest_grid_distance` now equals MESA's `Interp_rad`**: the distance to
+  the nearest tabulated model (empty cube nodes excluded), with axes
+  normalised by the range of the tabulated models. Previously it measured to
+  every node of the rectangular cube.
+- **`run_forward` warns** (`UserWarning`) when the query's grid cell touches a
+  node with no model; the interpolated result there is unreliable.
+  `AtmosphereGrid.cell_has_empty_nodes` exposes the check.
+- **`clamped` is no longer set by `interp_method='linear'`** merely because some
+  wavelength bins fell back to the nearest node at a populated, in-bounds point.
+
+### Inverse model
+
+The new fast evaluator calls the same Fortran kernels and agrees with
+`run_forward` to 1e-9 mag.
+
+### Changed (default behaviour)
+
+- **`run_inverse` now initialises walkers with a global search + Levenberg-
+  Marquardt refinement (`init='auto'`)** instead of a 2 % Gaussian ball at the
+  middle of the prior box. For the full Kurucz grid that ball sat in an empty
+  grid corner, and walkers that started there often never left it. In an
+  inject-and-recover benchmark (16-24 stars, 0.005-0.05 mag noise, Johnson /
+  optical+NIR / 11-band sets) the old default gave, with Av free, a Teff error
+  MAD of 10.9 % (now 1.6 %) and 12 % of fits with logg off by more than 4 sigma
+  (now 0.7 %); with Av and distance free the 95 % Teff coverage went from 0.72
+  to 0.91. Giving `p0_centre` (or `init='ball'`) restores the old behaviour
+  exactly, including emcee's stretch move.
+- With `init='auto'` the default sampler move is a differential-evolution
+  mixture (`moves='de'`), which halves the autocorrelation time and lets
+  walkers rebalance between modes; `moves='stretch'` restores the old move.
+- Grid nodes holding an all-zero SED (unphysical corners of Kurucz grids) now
+  give a zero posterior instead of finite magnitudes of ~770.
+- The likelihood no longer builds a full `ForwardResult` per call.
+
+### Added
+
+- `run_inverse` options: `init`, `sys_floor`, `fit_jitter` / `jitter_max`,
+  `priors` (`normal`, `halfnormal`, `parallax`, `edsd`, or callables),
+  `upper_limits`, `auto_stop`, `moves`, `pool`; `n_burn=None` for automatic
+  burn-in. Non-finite magnitudes are dropped with a warning.
+- `InverseResult`: `converged`, `n_eff`, `chi2_best`, `n_data`, `init_info`
+  (saved and loaded with `.npz`), and `credible_interval(name, level, method)`
+  with highest-posterior-density intervals.
+
 ## [0.3.2] — 2026-10-25
 
 - **Filter files from SED_Tools 0.4.0 load again.** SED_Tools 0.4.0 puts its

{sed_model-0.3.2 → sed_model-0.4.0}/CITATION.cff

@@ -7,7 +7,7 @@ authors:
   - family-names: "Miller"
     given-names: "Niall"
     email: "niall.j.miller@gmail.com"
-version: "0.3.2"
+version: "0.4.0"
 repository-code: "https://github.com/nialljmiller/SED_Model"
 url: "https://nialljmiller.github.io/SED_Model/"
 license: MIT

{sed_model-0.3.2 → sed_model-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sed-model
-Version: 0.3.2
+Version: 0.4.0
 Summary: Forward and inverse stellar photometry from SED grids.
 Keywords: astronomy,astrophysics,stellar astronomy,synthetic photometry,spectral energy distributions,sed,stellar parameters,bayesian inference,mcmc
 Author-Email: Niall Miller <niall.j.miller@gmail.com>
@@ -36,7 +36,7 @@ Description-Content-Type: text/markdown
 
 SED_Model is a Python package for computing observer-ready synthetic spectral energy distributions (SEDs) and broadband magnitudes from stellar atmosphere grids, and for recovering stellar parameters from observed photometry via Bayesian MCMC inference. It is designed to work directly downstream of `SED_Tools` and as a standalone drop-in for workflows that use MESA-style atmosphere grids and filter transmission curves.
 
-Version: `0.3.2`
+Version: `0.4.0`
 
 **Documentation:** https://nialljmiller.github.io/SED_Model/
 

{sed_model-0.3.2 → sed_model-0.4.0}/README.md

@@ -8,7 +8,7 @@
 
 SED_Model is a Python package for computing observer-ready synthetic spectral energy distributions (SEDs) and broadband magnitudes from stellar atmosphere grids, and for recovering stellar parameters from observed photometry via Bayesian MCMC inference. It is designed to work directly downstream of `SED_Tools` and as a standalone drop-in for workflows that use MESA-style atmosphere grids and filter transmission curves.
 
-Version: `0.3.2`
+Version: `0.4.0`
 
 **Documentation:** https://nialljmiller.github.io/SED_Model/
 

{sed_model-0.3.2 → sed_model-0.4.0}/docs/guide/forward.md

@@ -85,7 +85,7 @@ F_{\rm band} = \frac{\int F(\lambda)\, T(\lambda)\, \lambda\, d\lambda}{\int T(\
 m = -2.5 \log_{10}\!\left( F_{\rm band} / F_{zp} \right)
 \]
 
-with the zero-point \(F_{zp}\) precomputed per filter and system at load time ([Grids and Filters](grids-and-filters.md#zero-points)). Failed integrations or non-positive fluxes produce a sentinel magnitude of `-99.9` with a non-zero error flag rather than crashing.
+with the zero-point \(F_{zp}\) precomputed per filter and system at load time ([Grids and Filters](grids-and-filters.md#zero-points)). Failed integrations or non-positive fluxes produce a non-zero error flag rather than crashing: band magnitudes become `NaN` in `ForwardResult.magnitudes`, and the bolometric magnitude is `99.0` (MESA's value) when the integrated flux is not positive.
 
 ## Batch evaluation
 

{sed_model-0.3.2 → sed_model-0.4.0}/docs/guide/grids-and-filters.md

@@ -56,7 +56,7 @@ Filter files are two-column (wavelength Å, transmission 0–1); `#` comments ar
 
 ### Zero-points
 
-Each `Filter` carries precomputed photon-counting zero-points using the same integrals as MESA `colors/private/synthetic.f90`:
+Each `Filter` carries precomputed zero-points using the same integrals as MESA `colors/private/synthetic.f90` (photon counting, as MESA does by default). The photon-counting forms are:
 
 | System | Definition |
 |---|---|

sed_model-0.4.0/docs/guide/inverse.md

@@ -0,0 +1,116 @@
+# Inverse Model
+
+The inverse model recovers a posterior over stellar parameters from observed broadband photometry, using [`emcee`](https://emcee.readthedocs.io/) ensemble MCMC.
+
+## Statistical model
+
+- **Prior** — flat within the bounds of each free parameter (from [`FitParams`](parameters.md)); \(-\infty\) outside.
+- **Likelihood** — Gaussian per filter, summed:
+
+\[
+\ln \mathcal{L} = -\frac{1}{2} \sum_i \left[ \frac{(m_i^{\rm obs} - m_i^{\rm model})^2}{\sigma_i^2} + \ln\left(2\pi \sigma_i^2\right) \right]
+\]
+
+Model magnitudes come from the **same Fortran kernels, called in the same order, as `run_forward`** (interpolate, dilute, extinguish, convolve), minus the parts that do not affect magnitudes (bolometric integral, nearest-grid diagnostic, rebuilding the extinction model every call). A test checks agreement with `run_forward` to 1e-9 mag. Any exception inside the evaluation, a non-finite model magnitude, or a query that touches an *empty* grid node (Kurucz-type grids store unphysical corners, e.g. hot + low gravity, as all-zero SEDs that the forward model turns into finite magnitudes near 770) returns \(-\infty\) so the walker simply moves away.
+
+Optional extensions, all off by default:
+
+- `sys_floor=0.03` adds a systematic error floor (mag) in quadrature to every uncertainty.
+- `fit_jitter=True` samples one extra common term `sigma_sys` (flat on `[0, jitter_max]`), added in quadrature to all uncertainties; it appears as the last column of `samples`.
+- `priors={'d': ('parallax', 2.0, 0.05), 'a_v': ('halfnormal', 0.5), ...}` multiplies in extra priors (`normal`, `halfnormal`, `parallax` and `edsd` for distance, or any callable returning a log prior).
+- `upper_limits=[False, True, ...]` flags bands whose entry is a magnitude lower limit; they contribute \(\ln\Phi((m^{\rm model}-m^{\rm obs})/\sigma)\).
+- Non-finite magnitudes or uncertainties are dropped (with a warning) instead of poisoning the likelihood.
+
+## Basic usage
+
+```python
+from sed_model import run_inverse
+
+posterior = run_inverse(
+    obs_magnitudes=[5.03, 4.17],
+    obs_uncertainties=[0.01, 0.02],
+    filter_names=["G", "J"],
+    R=6.957e10,           # cm — always required, not sampled
+    d=3.086e19,           # cm — convenience: builds default FitParams with d fixed
+    grid=grid,
+    filters=filters,
+    mag_system="AB",
+    n_walkers=32, n_steps=2000, n_burn=500, n_thin=1,
+    seed=42,
+    progress=True,
+)
+```
+
+With no `fit_params` supplied, a default is built from the grid: `Teff`, `logg`, `[M/H]` free across the full grid, `Av` fixed at 0, distance fixed at `d` (default 1 pc). If `fit_params` **is** supplied, the `d` keyword is ignored — set distance through `fit_params`.
+
+## Choosing what to sample
+
+```python
+from sed_model import fit_params_from_grid
+from sed_model.params import PC_TO_CM
+
+# Av free with flat prior over [0, 3] mag
+params = fit_params_from_grid(grid, a_v=(0.0, 3.0), d_cm=500 * PC_TO_CM)
+
+# Av and distance both free — expect a correlated Av–d posterior
+params = fit_params_from_grid(
+    grid,
+    a_v=(0.0, 2.0),
+    d_cm=(100 * PC_TO_CM, 2000 * PC_TO_CM),
+)
+
+posterior = run_inverse(..., fit_params=params)
+```
+
+When `Av` is active (free, or fixed > 0) and no `extinction` model is supplied, a default Fitzpatrick (1999) model is created automatically; pass `extinction_law=...` or a full `ExtinctionModel` to control the prescription. See [Extinction](extinction.md).
+
+## Walker initialisation
+
+By default (`init='auto'`) the sampler does not start from a ball at the middle of the prior box (which, for the full Kurucz grid, is a 27 000 K, logg 2.5 point that lies in an empty corner of the grid). Instead it
+
+1. evaluates the posterior on a stratified (Latin hypercube) draw over the prior box, log-uniform in Teff and distance;
+2. refines the best few distinct candidates with Levenberg-Marquardt on the magnitude residuals (pure NumPy);
+3. estimates each optimum's covariance from the Gauss-Newton Jacobian and its relative posterior mass by importance sampling, and
+4. starts the walkers in those ellipsoids, giving every plausible mode a viable sub-ensemble.
+
+With `init='auto'` the ensemble uses a differential-evolution move mixture (`moves='de'`, including mode-hopping jumps), which rebalances walkers between modes and decorrelates about twice as fast as emcee's stretch move. Pass `moves='stretch'` for the old behaviour.
+
+To use the legacy Gaussian ball, give a starting point or ask for it:
+
+```python
+posterior = run_inverse(
+    ...,
+    p0_centre={"teff": 5800, "logg": 4.4, "meta": 0.0},   # implies init='ball'
+    p0_scatter=0.02,                                      # fraction of each range
+)
+```
+
+`n_burn=None` picks the burn-in automatically (twice the autocorrelation time, at most half the chain), and `auto_stop=True` samples in blocks and stops once the chain exceeds 50 autocorrelation times.
+
+## Input validation
+
+`run_inverse` raises `ValueError` before any sampling when:
+
+- `obs_magnitudes` and `obs_uncertainties` differ in length, or `filter_names` does not match them;
+- any uncertainty is ≤ 0 (the likelihood would be undefined);
+- a filter name is not among the supplied filters;
+- `n_walkers < 6`, `n_walkers < 2 × n_free`, or an integer `n_burn >= n_steps`;
+- every parameter is fixed (nothing to sample).
+
+## Diagnostics
+
+After sampling, a `UserWarning` is emitted if any walker's acceptance fraction falls below 0.1 or above 0.9. The result carries
+
+- `autocorr_time` (integrated autocorrelation time per parameter, `None` if it could not be estimated),
+- `converged` (`True` when the post-burn-in chain is longer than 50 autocorrelation times for every parameter) and `n_eff` (effective number of independent samples per parameter),
+- `chi2_best` / `n_data` (data chi-square of the maximum-posterior sample and the number of detected bands), and
+- `init_info` (how the walkers were started: method, number of modes, walkers per mode, likelihood evaluations).
+
+`posterior.credible_interval('meta', 0.68, method='hpd')` returns the shortest interval containing the requested mass; unlike the equal-tailed intervals in `summary()`, it extends to the bound when the posterior mode sits on a prior bound.
+
+!!! note "Calibration caveats"
+    Intervals are only as good as the model: with real photometry the atmosphere library, filter curves and zero points contribute systematic errors that the Gaussian likelihood does not know about (use `sys_floor` or `fit_jitter`). Fitting independent MIST bolometric-correction photometry (different atmospheres, filter curves and Vega zero point) with the Kurucz grid, the nominal 95 % Teff intervals covered the truth 46 % of the time; `sys_floor=0.03` raised that to 62 % and `fit_jitter=True` to 89 %. Weakly constrained parameters (logg from a few broad bands, Teff-Av degeneracy for few bands) have posteriors dominated by the flat prior and can be genuinely multimodal; check `converged`, and consider informative priors via `priors=`.
+
+## The result
+
+`run_inverse` returns an [`InverseResult`](results-io.md#inverseresult) holding the flattened post-burn-in chain (`samples`, shape `(n_samples, n_free)` with columns in `param_names` order), per-sample `log_prob`, the observations, sampler settings, acceptance fractions, and the fixed-parameter values used. See [Results and I/O](results-io.md) for summaries, MAP estimates, and `.npz` persistence.

{sed_model-0.3.2 → sed_model-0.4.0}/docs/index.md

@@ -8,7 +8,7 @@
 
 SED_Model is a Python package for computing observer-ready synthetic spectral energy distributions (SEDs) and broadband magnitudes from stellar atmosphere grids, and for recovering stellar parameters from observed photometry via Bayesian MCMC inference. It works directly downstream of [SED_Tools](https://github.com/nialljmiller/SED_Tools) and as a standalone drop-in for workflows that use MESA-style atmosphere grids and filter transmission curves.
 
-Current version: **0.3.2** ([PyPI](https://pypi.org/project/sed-model/))
+Current version: **0.4.0** ([PyPI](https://pypi.org/project/sed-model/))
 
 ## Two paired models, one parameter language
 

sed_model-0.4.0/docs/testing.md

@@ -0,0 +1,62 @@
+# Testing and Validation
+
+```bash
+pytest tests/test_forward.py
+pytest tests/test_inverse.py
+pytest tests/test_kernels.py
+```
+
+Run them from outside the source tree against an installed build; inside it `import sed_model` finds the uncompiled sources, has no extension, and every test skips.
+
+Both suites skip gracefully — with an explanatory reason — when the Fortran extension is not built or the required data products are not on disk, so `pytest` is always safe to run.
+
+## Data locations
+
+The tests look for SED_Tools data products in `~/.sed_tools/data`, then `~/SED_Tools/data`, then `$MESA_DIR/data/colors_data`, using the first location that exists. Each path can be overridden with an environment variable:
+
+| Variable | Path under the data root |
+|---|---|
+| `CC_KURUCZ_DIR` | `stellar_models/Kurucz2003all` |
+| `CC_JOHNSON_DIR` | `filters/Generic/Johnson` |
+| `CC_VEGA_SED` | `stellar_models/vega_flam.csv` |
+
+## Forward model: validated against MESA
+
+`tests/test_forward.py` checks grid loading, bounds/clamping, both interpolation schemes, filter loading and zero-points, and then the headline validation: synthetic magnitudes and bolometric quantities are compared against **reference values produced by the MESA colors unit test** (`colors/test/test_output`, MESA Kurucz2003 grid) for three stars spanning the grid — solar (5778 K / 4.44 / 0.0), a hot main-sequence star (15000 K / 4.0, 5 R☉), and a cool giant (4000 K / 2.0, 20 R☉).
+
+Tolerances are `TOL_MAG = 0.05` mag and `TOL_FLUX = 2%` relative — deliberately generous to absorb grid version differences and the trapezoid (Python zero-points) vs adaptive Simpson (Fortran in-band flux) integration difference, while still catching any real regression in the pipeline.
+
+## Inverse model: self-consistent recovery
+
+`tests/test_inverse.py` does not use external references. Instead it closes the loop on the package itself:
+
+1. run the forward model at known parameters to produce synthetic magnitudes,
+2. perturb them with a small known noise level (0.01 mag),
+3. run the inverse model and require the posterior median to recover the truth within physically motivated tolerances (≲ 2 grid spacings: 500 K in Teff, 0.5 dex in logg and [M/H]).
+
+Chains are kept deliberately short (hundreds of steps, 16 walkers) so the suite finishes quickly; the tolerances account for the resulting shot noise. The suite also covers the `InverseResult` API — summary structure and ordering, finite MAP estimates, `.npz` save/load round-trips, thinning behaviour — and the input-validation errors (mismatched array lengths, non-positive uncertainties, unknown filter names).
+
+## Cross-code validation (0.4.0)
+
+Before 0.4.0 the forward model was swept against the MESA `colors` module, MSG and MIST, and the inverse model was benchmarked by injection and recovery. Summary of what a user should expect:
+
+| Against | Result |
+|---|---|
+| **MESA colors** (standalone driver built from the MESA sources; Kurucz2003all, its alpha-enhanced variant and blackbodies; Johnson, 2MASS, Gaia, TESS, JWST and Argus filters; AB, Vega and ST; all three interpolation methods; on-node, off-node, cell-edge, corner and out-of-range queries) | SEDs, bolometric quantities and wavelengths identical; magnitudes within 3e-13 mag (double-precision rounding). |
+| **MSG** (same atmospheres, built into an MSG grid from the SED_Model cube) | `linear` agrees to about 1e-8. Hermite differs by 1e-5 to 1e-3 in clean cells because MSG's cubic includes cross-derivative terms. Photometry agrees to 1-4 mmag; U and B reach 13 mmag from quadrature on the coarse Johnson files. |
+| **MIST v2.5** bolometric corrections (C3K atmospheres, a different library) | 0.01-0.03 mag in V, I, 2MASS and Gaia at equal Teff, logg and [Fe/H]; up to 0.05-0.1 mag in U. These are model differences, not code errors. |
+
+Things that matter when comparing with other work:
+
+- **Weighting.** `synthetic_magnitude` counts photons, as MESA does. Energy weighting would change Gaia G by up to 0.25 mag for cool stars, so curves defined for energy-counting detectors (e.g. Bessell UBVRI) are weighted differently from what SED_Model currently does; support for per-filter detector type is pending.
+- **Filter definition.** The shipped `Generic/Johnson` curves are coarse and differ from Bessell/Cousins by up to 0.2 mag in R and I for cool stars.
+- **2MASS Vega zero points** follow Blanton and Roweis, about 0.025 mag from MIST's Cohen-based values.
+- **Empty grid cells.** A rectangular grid cube can contain nodes with no model (for Kurucz2003all about 40% of the cube). `run_forward` emits a `UserWarning` when the query's cell touches one, and the result there is unreliable. Hermite interpolation next to empty nodes can overshoot by 0.02-0.09 mag; this is MESA's behaviour and is reproduced exactly.
+
+Inverse recovery on the Kurucz grid (16-24 injected stars per set, 0.005-0.05 mag noise): the old mid-box start left walkers stuck in an empty corner and chains unconverged. With the 0.4.0 defaults, fitting Teff, logg, [M/H] and Av gives a Teff bias near 0.1 % and 95 % intervals that cover the truth about 94 % of the time. Photometry from a different atmosphere library (the MIST test) is far outside the nominal intervals unless `fit_jitter` is used, which is recommended for real photometry.
+
+The cross-code harnesses are not part of the repository; the in-repo regression tests (`tests/test_kernels.py`) encode the MESA cases that need no data.
+
+## What this means for the documentation
+
+Every numerical claim in these docs traces to one of three places: the source code (embedded directly in the [demo pages](demos/index.md)), the docstrings (rendered in the [API Reference](api.md)), or the test suite described here. Nothing is quoted from memory.

{sed_model-0.3.2 → sed_model-0.4.0}/fortran/cc_api.f90

@@ -190,7 +190,9 @@ contains
    !
    ! Steps performed internally:
    !   1. Interpolate filter transmission onto the SED wavelength grid
-   !   2. Photon-counting in-band flux integration
+   !   2. In-band flux integration (photon counting by default; energy
+   !      counting when photon_counting = 0, for filters tagged
+   !      '# DetectorType: energy' -- see sed_model.filters)
    !   3. m = -2.5 log10(F_band / F_zp)
    !
    ! Parameters
@@ -200,6 +202,7 @@ contains
    ! filt_wave(nf)       : filter wavelength grid (A)
    ! filt_trans(nf)      : filter transmission [0,1]
    ! zero_point          : precomputed photometric zero-point
+   ! photon_counting     : optional, 1 (default) photon / 0 energy weighting
    ! mag                 : output magnitude
    ! band_flux           : output in-band flux (before zero-point)
    ! ierr                : 0=ok, 1=integration failure, 2=non-positive flux
@@ -207,11 +210,13 @@ contains
    subroutine synthetic_magnitude(sed_wave, obs_flux, nw, &
                                    filt_wave, filt_trans, nf, &
                                    zero_point, &
-                                   mag, band_flux, ierr)
+                                   mag, band_flux, ierr, photon_counting)
       !f2py intent(in)  :: sed_wave, obs_flux, nw
       !f2py intent(in)  :: filt_wave, filt_trans, nf
       !f2py intent(in)  :: zero_point
       !f2py intent(out) :: mag, band_flux, ierr
+      !f2py integer, intent(in) :: photon_counting = 1
+      integer,  intent(in)  :: photon_counting   ! 1 = photon counting (default), 0 = energy counting
       integer,  intent(in)  :: nw, nf
       real(dp), intent(in)  :: sed_wave(nw), obs_flux(nw)
       real(dp), intent(in)  :: filt_wave(nf), filt_trans(nf)
@@ -227,7 +232,7 @@ contains
          mag = BAD_MAG; band_flux = -1.0_dp; return
       end if
 
-      call lib_synthetic_flux(sed_wave, obs_flux * filt_on_sed, filt_on_sed, band_flux)
+      call lib_synthetic_flux(sed_wave, obs_flux * filt_on_sed, filt_on_sed, band_flux, photon_counting /= 0)
       if (band_flux <= 0.0_dp) then
          mag = BAD_MAG; ierr = 1; return
       end if
@@ -265,43 +270,49 @@ contains
 
    subroutine vega_zero_point(vega_wave, vega_flux, nv, &
                                filt_wave, filt_trans, nf, &
-                               zp, ierr)
+                               zp, ierr, photon_counting)
       !f2py intent(in)  :: vega_wave, vega_flux, nv
       !f2py intent(in)  :: filt_wave, filt_trans, nf
       !f2py intent(out) :: zp, ierr
+      !f2py integer, intent(in) :: photon_counting = 1
+      integer,  intent(in)  :: photon_counting
       integer,  intent(in)  :: nv, nf
       real(dp), intent(in)  :: vega_wave(nv), vega_flux(nv)
       real(dp), intent(in)  :: filt_wave(nf), filt_trans(nf)
       real(dp), intent(out) :: zp
       integer,  intent(out) :: ierr
 
-      zp = lib_vega_zp(vega_wave, vega_flux, filt_wave, filt_trans)
+      zp = lib_vega_zp(vega_wave, vega_flux, filt_wave, filt_trans, photon_counting /= 0)
       ierr = merge(0, 1, zp > 0.0_dp)
    end subroutine vega_zero_point
 
 
-   subroutine ab_zero_point(filt_wave, filt_trans, nf, zp, ierr)
+   subroutine ab_zero_point(filt_wave, filt_trans, nf, zp, ierr, photon_counting)
       !f2py intent(in)  :: filt_wave, filt_trans, nf
       !f2py intent(out) :: zp, ierr
+      !f2py integer, intent(in) :: photon_counting = 1
+      integer,  intent(in)  :: photon_counting
       integer,  intent(in)  :: nf
       real(dp), intent(in)  :: filt_wave(nf), filt_trans(nf)
       real(dp), intent(out) :: zp
       integer,  intent(out) :: ierr
 
-      zp = lib_ab_zp(filt_wave, filt_trans)
+      zp = lib_ab_zp(filt_wave, filt_trans, photon_counting /= 0)
       ierr = merge(0, 1, zp > 0.0_dp)
    end subroutine ab_zero_point
 
 
-   subroutine st_zero_point(filt_wave, filt_trans, nf, zp, ierr)
+   subroutine st_zero_point(filt_wave, filt_trans, nf, zp, ierr, photon_counting)
       !f2py intent(in)  :: filt_wave, filt_trans, nf
       !f2py intent(out) :: zp, ierr
+      !f2py integer, intent(in) :: photon_counting = 1
+      integer,  intent(in)  :: photon_counting
       integer,  intent(in)  :: nf
       real(dp), intent(in)  :: filt_wave(nf), filt_trans(nf)
       real(dp), intent(out) :: zp
       integer,  intent(out) :: ierr
 
-      zp = lib_st_zp(filt_wave, filt_trans)
+      zp = lib_st_zp(filt_wave, filt_trans, photon_counting /= 0)
       ierr = merge(0, 1, zp > 0.0_dp)
    end subroutine st_zero_point
 

{sed_model-0.3.2 → sed_model-0.4.0}/fortran/private/bolometric.f90

@@ -22,7 +22,7 @@
 ! ***********************************************************************
 
 module bolometric
-   use colors_def, only: dp, BAD_MAG, F_BOL_ZERO_POINT
+   use colors_def, only: dp, BOL_MAG_NONPOSITIVE_FLUX, F_BOL_ZERO_POINT
    use colors_utils, only: simpson_integration, is_finite
    implicit none
 
@@ -75,7 +75,7 @@ contains
       if (bol_flux > 0.0_dp) then
          bol_mag = -2.5_dp * log10(bol_flux / F_BOL_ZERO_POINT)
       else
-         bol_mag = BAD_MAG
+         bol_mag = BOL_MAG_NONPOSITIVE_FLUX
          ierr = 1
       end if
    end subroutine bolometric_magnitude

{sed_model-0.3.2 → sed_model-0.4.0}/fortran/private/synthetic.f90

@@ -35,18 +35,30 @@ module synthetic
 
 contains
 
-   ! Photon-counting in-band flux from an already-convolved SED:
+   ! In-band flux from an already-convolved SED.  Photon counting (the
+   ! default, as in MESA):
    !   F_band = integral(convolved_flux * lambda) / integral(filter * lambda)
+   ! Energy counting (filters tagged '# DetectorType: energy'):
+   !   F_band = integral(convolved_flux) / integral(filter)
    ! `convolved_flux` is obs_flux * filter_on_sed_grid, computed by the
    ! caller -- matches MESA's calling convention in synthetic.f90.
-   subroutine calculate_synthetic_flux(wavelengths, convolved_flux, filter_on_sed_grid, synthetic_flux)
+   subroutine calculate_synthetic_flux(wavelengths, convolved_flux, filter_on_sed_grid, synthetic_flux, photon_counting)
       real(dp), intent(in)  :: wavelengths(:), convolved_flux(:), filter_on_sed_grid(:)
       real(dp), intent(out) :: synthetic_flux
+      logical, optional, intent(in) :: photon_counting
 
       real(dp) :: integrated_flux, integrated_filter
+      logical :: use_photons
 
-      call simpson_integration(wavelengths, convolved_flux * wavelengths, integrated_flux)
-      call simpson_integration(wavelengths, filter_on_sed_grid * wavelengths, integrated_filter)
+      use_photons = .true.
+      if (present(photon_counting)) use_photons = photon_counting
+      if (use_photons) then
+         call simpson_integration(wavelengths, convolved_flux * wavelengths, integrated_flux)
+         call simpson_integration(wavelengths, filter_on_sed_grid * wavelengths, integrated_filter)
+      else
+         call simpson_integration(wavelengths, convolved_flux, integrated_flux)
+         call simpson_integration(wavelengths, filter_on_sed_grid, integrated_filter)
+      end if
 
       if (integrated_filter > 0.0_dp) then
          synthetic_flux = integrated_flux / integrated_filter
@@ -72,36 +84,30 @@ contains
 
 
    ! Vega zero-point -- called once at filter-load time.
-   real(dp) function compute_vega_zero_point(vega_wave, vega_flux, filt_wave, filt_trans)
+   real(dp) function compute_vega_zero_point(vega_wave, vega_flux, filt_wave, filt_trans, photon_counting)
       real(dp), intent(in) :: vega_wave(:), vega_flux(:)
       real(dp), intent(in) :: filt_wave(:), filt_trans(:)
+      logical, optional, intent(in) :: photon_counting
 
-      real(dp) :: int_flux, int_filter
       real(dp), allocatable :: filt_on_vega(:)
       integer :: ierr
 
       allocate (filt_on_vega(size(vega_wave)))
       call interp_filter_onto_sed(filt_wave, filt_trans, vega_wave, filt_on_vega, ierr)
 
-      call simpson_integration(vega_wave, vega_flux * filt_on_vega * vega_wave, int_flux)
-      call simpson_integration(vega_wave, filt_on_vega * vega_wave, int_filter)
-
-      if (int_filter > 0.0_dp) then
-         compute_vega_zero_point = int_flux / int_filter
-      else
-         compute_vega_zero_point = -1.0_dp
-      end if
+      call calculate_synthetic_flux(vega_wave, vega_flux * filt_on_vega, filt_on_vega, &
+                                    compute_vega_zero_point, photon_counting)
 
       deallocate (filt_on_vega)
    end function compute_vega_zero_point
 
 
    ! AB zero-point -- f_nu = 3631 Jy converted to f_lambda on the filter grid.
-   real(dp) function compute_ab_zero_point(filt_wave, filt_trans)
+   real(dp) function compute_ab_zero_point(filt_wave, filt_trans, photon_counting)
       real(dp), intent(in) :: filt_wave(:), filt_trans(:)
+      logical, optional, intent(in) :: photon_counting
 
       integer  :: i
-      real(dp) :: int_flux, int_filter
       real(dp), allocatable :: f_ab(:)
 
       allocate (f_ab(size(filt_wave)))
@@ -113,37 +119,25 @@ contains
          end if
       end do
 
-      call simpson_integration(filt_wave, f_ab * filt_trans * filt_wave, int_flux)
-      call simpson_integration(filt_wave, filt_trans * filt_wave, int_filter)
-
-      if (int_filter > 0.0_dp) then
-         compute_ab_zero_point = int_flux / int_filter
-      else
-         compute_ab_zero_point = -1.0_dp
-      end if
+      call calculate_synthetic_flux(filt_wave, f_ab * filt_trans, filt_trans, &
+                                    compute_ab_zero_point, photon_counting)
 
       deallocate (f_ab)
    end function compute_ab_zero_point
 
 
    ! ST zero-point -- flat f_lambda = 3.63e-9 erg/s/cm^2/A.
-   real(dp) function compute_st_zero_point(filt_wave, filt_trans)
+   real(dp) function compute_st_zero_point(filt_wave, filt_trans, photon_counting)
       real(dp), intent(in) :: filt_wave(:), filt_trans(:)
+      logical, optional, intent(in) :: photon_counting
 
-      real(dp) :: int_flux, int_filter
       real(dp), allocatable :: f_st(:)
 
       allocate (f_st(size(filt_wave)))
       f_st = ST_FLAM_ZP
 
-      call simpson_integration(filt_wave, f_st * filt_trans * filt_wave, int_flux)
-      call simpson_integration(filt_wave, filt_trans * filt_wave, int_filter)
-
-      if (int_filter > 0.0_dp) then
-         compute_st_zero_point = int_flux / int_filter
-      else
-         compute_st_zero_point = -1.0_dp
-      end if
+      call calculate_synthetic_flux(filt_wave, f_st * filt_trans, filt_trans, &
+                                    compute_st_zero_point, photon_counting)
 
       deallocate (f_st)
    end function compute_st_zero_point

{sed_model-0.3.2 → sed_model-0.4.0}/fortran/public/colors_def.f90

@@ -25,7 +25,10 @@ module colors_def
    real(dp), parameter :: CLIGHT_CM_S  = 2.99792458d10
    real(dp), parameter :: AB_FNU_ZP    = 3.631d-20      ! 3631 Jy in erg/s/cm^2/Hz
    real(dp), parameter :: ST_FLAM_ZP   = 3.63d-9        ! flat f_lambda zp erg/s/cm^2/A
-   real(dp), parameter :: BAD_MAG      = -99.9d0        ! failure sentinel for magnitudes
+   real(dp), parameter :: BAD_MAG      = -99.9d0        ! failure sentinel for band magnitudes
+   ! MESA colors/private/bolometric.f90 returns 99.0 as the bolometric
+   ! magnitude when the integrated flux is not positive.
+   real(dp), parameter :: BOL_MAG_NONPOSITIVE_FLUX = 99.0d0
    real(dp), parameter :: TINY_VALUE   = 1.0d-300        ! positivity floor for linear interpolation
 
    ! Bolometric zero-point: irradiance corresponding to M_bol = 0 (IAU 2015
@@ -39,7 +42,7 @@ module colors_def
       LSUN_ERG_S * 10.0_dp**(0.4_dp*MBOL_SUN) / (4.0_dp*PI_DP*(10.0_dp*PC_CM)**2)
 
    public :: dp
-   public :: CLIGHT_CM_S, AB_FNU_ZP, ST_FLAM_ZP, BAD_MAG, TINY_VALUE
+   public :: CLIGHT_CM_S, AB_FNU_ZP, ST_FLAM_ZP, BAD_MAG, BOL_MAG_NONPOSITIVE_FLUX, TINY_VALUE
    public :: F_BOL_ZERO_POINT
 
 end module colors_def

{sed_model-0.3.2 → sed_model-0.4.0}/meson.build

@@ -2,7 +2,7 @@
 # and for the others the checks below give a readable error if one is missing.
 project(
   'sed_model',
-  version: '0.3.2',
+  version: '0.4.0',
   meson_version: '>=1.1.0',
 )
 
@@ -34,6 +34,7 @@ if components in ['all', 'python']
     files(
       'sed_model/__init__.py',
       'sed_model/_cc_ext.py',
+      'sed_model/_inv_core.py',
       'sed_model/filters.py',
       'sed_model/forward.py',
       'sed_model/grid.py',