eclipse 0.13.0__tar.gz → 0.14.0__tar.gz

{eclipse-0.13.0/src/eclipse.egg-info → eclipse-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eclipse
-Version: 0.13.0
+Version: 0.14.0
 Summary: ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
 Author-email: James McKevitt <jm2@mssl.ucl.ac.uk>
 Project-URL: Homepage, https://github.com/jamesmckevitt/eclipse
@@ -61,8 +61,6 @@ The instrument model will be updated as EUVST is built, tested and commissioned.
 [![PyPI](https://img.shields.io/pypi/v/eclipse.svg)](https://pypi.org/project/eclipse/)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.17543844-blue.svg)](https://doi.org/10.5281/zenodo.17543844)
 
-ECLIPSE is installed with `pip install eclipse`. ECLIPSE 0.12 and earlier were on PyPI as `solarc-eclipse`.
-
 The documentation, with installation and a first run, guides to synthesising spectra, simulating the instrument and analysing the results, and a worked example, is at **[solarc-eclipse.readthedocs.io](https://solarc-eclipse.readthedocs.io)**.
 
 ## Acknowledgements

{eclipse-0.13.0 → eclipse-0.14.0}/README.md

@@ -11,8 +11,6 @@ The instrument model will be updated as EUVST is built, tested and commissioned.
 [![PyPI](https://img.shields.io/pypi/v/eclipse.svg)](https://pypi.org/project/eclipse/)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.17543844-blue.svg)](https://doi.org/10.5281/zenodo.17543844)
 
-ECLIPSE is installed with `pip install eclipse`. ECLIPSE 0.12 and earlier were on PyPI as `solarc-eclipse`.
-
 The documentation, with installation and a first run, guides to synthesising spectra, simulating the instrument and analysing the results, and a worked example, is at **[solarc-eclipse.readthedocs.io](https://solarc-eclipse.readthedocs.io)**.
 
 ## Acknowledgements

{eclipse-0.13.0 → eclipse-0.14.0}/src/eclipse/__init__.py

@@ -4,7 +4,7 @@ ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
 Tools for modeling the performance of EUVST, the EUV spectrograph on SOLAR-C.
 """
 
-__version__ = "0.13.0"
+__version__ = "0.14.0"
 __author__ = "James McKevitt"
 __email__ = "jm2@mssl.ucl.ac.uk"
 

{eclipse-0.13.0 → eclipse-0.14.0}/src/eclipse/fitting.py

@@ -71,6 +71,15 @@ class FitComponent:
     name : str, optional
         Name in the results. Default the rest wavelength, e.g.
         `"195.1190 Angstrom"`.
+    velocity_limits : tuple of u.Quantity, optional
+        Lowest and highest velocity the fit may give this line, measured
+        from its rest wavelength, such as `(-60 * u.km / u.s, 60 * u.km / u.s)`.
+        Not for a line whose centre is tied to another's. Default None, for
+        no limits.
+    width_limits : tuple of u.Quantity, optional
+        Smallest and largest Gaussian sigma the fit may give this line, such
+        as `(0.019 * u.AA, 0.051 * u.AA)`. Not for a line whose width is tied
+        to another's. Default None, for no limits.
     """
     wavelength: u.Quantity
     tie_center: Optional[int] = None   # index of component whose centre this is tied to
@@ -79,6 +88,8 @@ class FitComponent:
     # Label for this component in the results. Defaults to its rest
     # wavelength, e.g. "195.1190 Angstrom".
     name: Optional[str] = None
+    velocity_limits: Optional[tuple] = None
+    width_limits: Optional[tuple] = None
 
     def __post_init__(self):
         # Catch a wavelength with no unit here rather than in the fit.
@@ -87,6 +98,38 @@ class FitComponent:
                 and np.isfinite(self.wavelength.value) and self.wavelength.value > 0):
             raise ValueError(f"A fitting component's wavelength must be the wavelength of a "
                              f"line, such as '195.119 AA'; got {self.wavelength!r}.")
+        for key, kind, example in (("velocity_limits", u.km / u.s, "[-60 km/s, 60 km/s]"),
+                                   ("width_limits", u.AA, "[0.019 AA, 0.051 AA]")):
+            value = getattr(self, key)
+            if value is None:
+                continue
+            try:
+                low, high = (u.Quantity(v) for v in value)
+            except (TypeError, ValueError):
+                low = high = None
+            if (low is None or not low.unit.is_equivalent(kind)
+                    or not high.unit.is_equivalent(kind)
+                    or not (np.isfinite(low.value) and np.isfinite(high.value))
+                    or not low < high or (key == "width_limits" and low <= 0)):
+                raise ValueError(
+                    f"A fitting component's {key} must be two {kind.physical_type}s, the "
+                    f"lower first{', both above zero' if key == 'width_limits' else ''}, "
+                    f"such as {example}; got {value!r}.")
+            setattr(self, key, (low.to(kind), high.to(kind)))
+
+    def centre_limits(self) -> Optional[tuple]:
+        """Lowest and highest centre in cm that `velocity_limits` allow, or None."""
+        if self.velocity_limits is None:
+            return None
+        rest = self.wavelength.to_value(u.cm)
+        c = const.c.to_value(u.km / u.s)
+        return tuple(rest * (1 + v.to_value(u.km / u.s) / c) for v in self.velocity_limits)
+
+    def sigma_limits(self) -> Optional[tuple]:
+        """Smallest and largest sigma in cm that `width_limits` allow, or None."""
+        if self.width_limits is None:
+            return None
+        return tuple(w.to_value(u.cm) for w in self.width_limits)
 
 
 def default_component_name(wavelength: u.Quantity) -> str:
@@ -123,6 +166,11 @@ class FitConfig:
         Weight each pixel of the DN spectra by one over its uncertainty
         squared, estimated from its own signal as eispac does, and fit the
         photon spectra by their Poisson likelihood. Default True.
+    start : str
+        Where each fit of a blend starts: `"search"` (default) slides the
+        components together along the spectrum to where they best match it;
+        `"rest"` starts every component at its rest wavelength, as eispac's
+        templates do.
     """
     components: List[FitComponent] = field(default_factory=list)
     primary_component: int = 0
@@ -146,6 +194,10 @@ class FitConfig:
     # its position count no more than its noisier peak. Results files from
     # before this setting are unweighted.
     weighted: bool = True
+    # Where a blend's fit starts. A search can start a faint blend a whole
+    # component spacing from the truth; starting at rest, as eispac does,
+    # keeps it on the line that is there.
+    start: str = "search"
 
     def __post_init__(self):
         if len(self.components) == 1:
@@ -154,6 +206,8 @@ class FitConfig:
                 "needs at least two; for a single Gaussian leave components "
                 "out, and the other fitting settings still apply."
             )
+        if self.start not in ("search", "rest"):
+            raise ValueError(f"fitting.start must be 'search' or 'rest', got {self.start!r}.")
         if self.backend not in (None, "scipy", "mpfit"):
             raise ValueError(
                 f"Unknown fitting backend '{self.backend}'. "
@@ -194,6 +248,12 @@ class FitConfig:
                             f"has to be the index of another component, from "
                             f"0 to {n - 1}."
                         )
+                for key, tie in (("velocity_limits", "tie_center"), ("width_limits", "tie_width")):
+                    if getattr(comp, key) is not None and getattr(comp, tie) is not None:
+                        raise ValueError(
+                            f"fitting.components[{idx}] has {key} and {tie}. A tied "
+                            f"component follows the one it is tied to, so give the limits "
+                            f"to that one.")
                 if comp.name is not None and (
                         not isinstance(comp.name, str) or not comp.name.strip()):
                     raise ValueError(
@@ -229,7 +289,7 @@ class FitConfig:
                     f"the components a 'name'."
                 )
         else:
-            # Both settings need components; without them they would
+            # These settings need components; without them they would
             # silently do nothing.
             if self.primary_component != 0:
                 raise ValueError(
@@ -241,6 +301,11 @@ class FitConfig:
                     "fitting.constrain_positive_intensity is only applied to "
                     "multi-component fits, and there are no components."
                 )
+            if self.start != "search":
+                raise ValueError(
+                    "fitting.start is only applied to multi-component fits, and there are "
+                    "no components."
+                )
 
     @property
     def n_components(self) -> int:
@@ -678,7 +743,16 @@ def _build_scipy_multi(fit_config: FitConfig, pixel_angstrom: float | None = Non
         for pos, fi in enumerate(free_indices):
             if fi % 3 == 0 and fi < 3 * nc and pos not in ratio_spec:
                 lower[pos] = 0.0
-    has_bounds = ratio_spec or fit_config.constrain_positive_intensity
+    # Limits on each component's centre and width, in Angstrom.
+    limited = False
+    for pos, fi in enumerate(free_indices):
+        if fi < 3 * nc and fi % 3 in (1, 2):
+            comp = fit_config.components[fi // 3]
+            limits = comp.centre_limits() if fi % 3 == 1 else comp.sigma_limits()
+            if limits is not None:
+                lower[pos], upper[pos] = (value * 1e8 for value in limits)
+                limited = True
+    has_bounds = ratio_spec or fit_config.constrain_positive_intensity or limited
     bounds = (lower, upper) if has_bounds else (-np.inf, np.inf)
 
     # Order the ratios so parents come before their children.
@@ -881,6 +955,9 @@ def _build_parinfo(fit_config: FitConfig, p0: np.ndarray,
                            / fit_config.components[src].wavelength.to(u.cm).value)
             # mpfit tie expression references the parameter array p
             centre_info["tied"] = f"p[{3 * src + 1}] * {factor!r}"
+        elif (centre_limits := comp.centre_limits()) is not None:
+            centre_info["limited"] = [1, 1]
+            centre_info["limits"] = list(centre_limits)
         parinfo.append(centre_info)
 
         # --- sigma (width) ---
@@ -888,6 +965,9 @@ def _build_parinfo(fit_config: FitConfig, p0: np.ndarray,
         # Width must be strictly positive (avoid divide-by-zero in Gaussian)
         sigma_info["limited"] = [1, 0]
         sigma_info["limits"] = [1e-30, 0.0]
+        if (sigma_limits := comp.sigma_limits()) is not None:
+            sigma_info["limited"] = [1, 1]
+            sigma_info["limits"] = list(sigma_limits)
         if comp.tie_width is not None:
             src = _tie_root(fit_config, "tie_width", i)
             sigma_info["tied"] = f"p[{3 * src + 2}]"
@@ -982,16 +1062,28 @@ def _guess_multi_params(wv: np.ndarray, prof: np.ndarray,
     rest_wl = np.array([c.wavelength.to(u.cm).value
                         for c in fit_config.components])
     ref_wl = float(rest_wl[fit_config.primary_component])
-    if peak > 0:
+    # Shifts of the whole comb that keep each component within its velocity
+    # limits.
+    allowed = [-np.inf, np.inf]
+    for comp, rest in zip(fit_config.components, rest_wl):
+        limits = comp.centre_limits()
+        if limits is not None:
+            low_centre, high_centre = limits
+            allowed[0] = max(allowed[0], ref_wl * low_centre / rest - ref_wl)
+            allowed[1] = min(allowed[1], ref_wl * high_centre / rest - ref_wl)
+    # With start "rest", every component starts at its rest wavelength, as
+    # eispac's templates do.
+    if fit_config.start == "search" and peak > 0:
         # A trial shift moves the primary centre to ref_wl + shift and every
         # other component to its rest wavelength times the same factor. The
         # range keeps the whole comb inside the observed window; with all
         # components at one wavelength it reduces to shifting the comb bodily.
         lo = float(wv.min()) * ref_wl / float(rest_wl.min()) - ref_wl
         hi = float(wv.max()) * ref_wl / float(rest_wl.max()) - ref_wl
+        lo, hi = max(lo, allowed[0]), min(hi, allowed[1])
         step = float(np.median(np.diff(wv))) if len(wv) > 1 else 0.0
         if hi > lo and step > 0:
-            trial = np.arange(lo, hi + 0.5 * step, step)
+            trial = np.minimum(np.arange(lo, hi + 0.5 * step, step), hi)
             score = np.zeros(trial.size)
             for r in rest_wl:
                 score += np.interp(r * (ref_wl + trial) / ref_wl, wv, prof_c,
@@ -1006,8 +1098,8 @@ def _guess_multi_params(wv: np.ndarray, prof: np.ndarray,
             # nothing to recover.
             shift = float(trial[int(np.argmax(score))])
         else:
-            # The comb is wider than the window, so no shift keeps all of it
-            # inside. Fall back to the brightest pixel and the component
+            # No shift keeps the comb inside the window and within the
+            # limits. Fall back to the brightest pixel and the component
             # nearest to it, read as a Doppler factor.
             peak_wl = float(wv[np.nanargmax(prof_c)])
             nearest = float(rest_wl[np.argmin(np.abs(rest_wl - peak_wl))])
@@ -1015,6 +1107,8 @@ def _guess_multi_params(wv: np.ndarray, prof: np.ndarray,
     else:
         shift = 0.0
 
+    if allowed[0] <= allowed[1]:
+        shift = float(np.clip(shift, *allowed))
     doppler = (ref_wl + shift) / ref_wl
     full_guess = np.zeros(fit_config.n_full_params)
     for i, comp in enumerate(fit_config.components):
@@ -1022,6 +1116,12 @@ def _guess_multi_params(wv: np.ndarray, prof: np.ndarray,
         full_guess[base] = peak if i == fit_config.primary_component else peak * 0.15
         full_guess[base + 1] = rest_wl[i] * doppler
         full_guess[base + 2] = sigma
+    # A start outside a component's limits is moved to the nearest limit, as
+    # the optimisers need one inside them.
+    for i, comp in enumerate(fit_config.components):
+        for offset, limits in ((1, comp.centre_limits()), (2, comp.sigma_limits())):
+            if limits is not None:
+                full_guess[3 * i + offset] = np.clip(full_guess[3 * i + offset], *limits)
     full_guess[-1] = back
     return full_guess
 

{eclipse-0.13.0 → eclipse-0.14.0}/src/eclipse/main.py

@@ -137,9 +137,10 @@ _SIMULATION_KEYS = {"slit_width", "expos", "vis_sl", "psf", "psf_boundary",
 
 _FITTING_KEYS = {"components", "primary_component",
                  "constrain_positive_intensity", "backend", "max_iter",
-                 "bessel_correction", "save_iterations", "weighted"}
+                 "bessel_correction", "save_iterations", "weighted", "start"}
 _FITTING_COMPONENT_KEYS = {"wavelength", "tie_center", "tie_width",
-                           "amplitude_greater_than", "name"}
+                           "amplitude_greater_than", "name", "velocity_limits",
+                           "width_limits"}
 
 
 def _dataclass_keys(cls) -> set:
@@ -472,6 +473,8 @@ def _parse_fitting_config(config: dict) -> FitConfig | None:
             tie_width=comp_dict.get("tie_width", None),
             amplitude_greater_than=comp_dict.get("amplitude_greater_than", None),
             name=comp_dict.get("name", None),
+            velocity_limits=comp_dict.get("velocity_limits"),
+            width_limits=comp_dict.get("width_limits"),
         ))
 
     return FitConfig(
@@ -484,6 +487,7 @@ def _parse_fitting_config(config: dict) -> FitConfig | None:
         bessel_correction=fitting_cfg.get("bessel_correction", False),
         save_iterations=fitting_cfg.get("save_iterations", False),
         weighted=fitting_cfg.get("weighted", True),
+        start=fitting_cfg.get("start", "search"),
     )
 
 

{eclipse-0.13.0 → eclipse-0.14.0}/src/eclipse/results_file.py

@@ -353,7 +353,8 @@ def _jsonable(value):
 # FitConfig.weighted, and None is the detector material's value.
 _MATERIAL = {"fano_factor": None, "pair_energy_300k": None, "pair_energy_slope": None}
 _EARLIER_VALUES = {
-    "FitConfig": {"weighted": False},
+    "FitConfig": {"weighted": False, "start": "search"},
+    "FitComponent": {"velocity_limits": None, "width_limits": None},
     "Telescope_EUVST": {"resolution_budget": "none"},
     "Detector_SWC": {**_MATERIAL,
                      "dispersion": (198.885944, 1.2516577, -1.361114e-4),

{eclipse-0.13.0 → eclipse-0.14.0/src/eclipse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eclipse
-Version: 0.13.0
+Version: 0.14.0
 Summary: ECLIPSE: Emission Calculation and Line Prediction for SOLAR-C EUVST
 Author-email: James McKevitt <jm2@mssl.ucl.ac.uk>
 Project-URL: Homepage, https://github.com/jamesmckevitt/eclipse
@@ -61,8 +61,6 @@ The instrument model will be updated as EUVST is built, tested and commissioned.
 [![PyPI](https://img.shields.io/pypi/v/eclipse.svg)](https://pypi.org/project/eclipse/)
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.17543844-blue.svg)](https://doi.org/10.5281/zenodo.17543844)
 
-ECLIPSE is installed with `pip install eclipse`. ECLIPSE 0.12 and earlier were on PyPI as `solarc-eclipse`.
-
 The documentation, with installation and a first run, guides to synthesising spectra, simulating the instrument and analysing the results, and a worked example, is at **[solarc-eclipse.readthedocs.io](https://solarc-eclipse.readthedocs.io)**.
 
 ## Acknowledgements

{eclipse-0.13.0 → eclipse-0.14.0}/src/eclipse.egg-info/SOURCES.txt

@@ -71,6 +71,7 @@ tests/test_fit_constraints.py
 tests/test_fit_finite.py
 tests/test_fit_multi_start.py
 tests/test_fit_quality.py
+tests/test_fit_rest_start_and_limits.py
 tests/test_fit_start.py
 tests/test_fit_summaries.py
 tests/test_fit_weighting.py

eclipse-0.14.0/tests/test_fit_rest_start_and_limits.py

@@ -0,0 +1,243 @@
+"""A blend started at its rest wavelengths, and limits on each component's velocity and width.
+
+Started this way, as eispac's templates are, a faint blend stays on its line.
+"""
+import astropy.constants as const
+import astropy.units as u
+import numpy as np
+import pytest
+import yaml
+from astropy.wcs import WCS
+from ndcube import NDCube
+
+from eclipse.fitting import FitComponent, FitConfig, _guess_multi_params, fit_cube_gauss
+from eclipse.results_file import load_results, save_results
+
+STEP = 0.0169 * u.Angstrom
+N_WAVE = 31
+CENTRE = 195.13 * u.Angstrom
+STRONG, FAINT = 195.119 * u.Angstrom, 195.179 * u.Angstrom
+SIGMA = 0.027 * u.Angstrom
+C_KM_S = const.c.to_value(u.km / u.s)
+# eispac's fe_12_195_119.2c template: the centre within 0.04 Angstrom of rest
+# and the width between 0.0191 and 0.0510 Angstrom.
+EISPAC = dict(velocity_limits=(-61.5 * u.km / u.s, 61.5 * u.km / u.s),
+              width_limits=(0.0191 * u.AA, 0.0510 * u.AA))
+
+
+def _wave():
+    return CENTRE + (np.arange(N_WAVE) - (N_WAVE - 1) / 2) * STEP
+
+
+def _cube(spectra):
+    """Spectra, shaped (n, N_WAVE), as a (1, n, N_WAVE) cube."""
+    wcs = WCS(naxis=3)
+    wcs.wcs.ctype = ["WAVE", "HPLN-TAN", "HPLT-TAN"]
+    wcs.wcs.cunit = ["cm", "arcsec", "arcsec"]
+    wcs.wcs.cdelt = [STEP.to_value(u.cm), 0.4, 0.16]
+    wcs.wcs.crpix = [(N_WAVE + 1) / 2, 1.0, 1.0]
+    wcs.wcs.crval = [CENTRE.to_value(u.cm), 0.0, 0.0]
+    return NDCube(np.asarray(spectra)[np.newaxis], wcs=wcs, unit=u.DN / u.pix)
+
+
+def _blend(velocity=0.0, strong=100.0, ratio=0.06, background=5.0):
+    """Fe XII 195.119 and a 195.179 `ratio` as bright, at `velocity` km/s."""
+    wave = _wave()
+    return background + sum(
+        peak * np.exp(-0.5 * ((wave - rest * (1 + velocity / C_KM_S)) / SIGMA)
+                      .decompose().value ** 2)
+        for peak, rest in ((strong, STRONG), (strong * ratio, FAINT)))
+
+
+def _components(primary=None, **limits):
+    return [FitComponent(STRONG, **(primary or {}), **limits),
+            FitComponent(FAINT, tie_center=0, tie_width=0)]
+
+
+def _velocity(params):
+    return (params[..., 1] * u.cm / STRONG.to(u.cm) - 1).value * C_KM_S
+
+
+@pytest.mark.parametrize("backend", ["scipy", "mpfit"])
+def test_a_noisy_faint_blend_started_at_rest_and_limited_stays_on_its_line(backend):
+    """
+    With a few dozen counts in the line, a search start lands some fits a
+    line spacing, 92 km/s, from the truth; at rest within eispac's limits
+    none do.
+    """
+    rng = np.random.default_rng(3)
+    truth = _blend(strong=30.0)
+    spectra = rng.poisson(np.tile(truth, (400, 1))).astype(float)
+    cube = _cube(spectra)
+
+    def far(**settings):
+        config = FitConfig(components=_components(**settings.pop("limits", {})),
+                           constrain_positive_intensity=True, backend=backend, **settings)
+        data, _, failed = fit_cube_gauss(cube, n_jobs=1, fit_config=config, return_failed=True)
+        velocity = _velocity(data[0])[~failed[0]]
+        return np.mean(np.abs(velocity) > 45)
+
+    searched = far()
+    rested = far(start="rest", limits=EISPAC)
+    assert searched > 0.02
+    assert rested < searched / 4
+
+
+@pytest.mark.parametrize("backend", ["scipy", "mpfit"])
+def test_a_line_beyond_its_velocity_limit_is_fitted_at_the_limit(backend):
+    """
+    The line is to the blue. To the red, the faint component, 92 km/s to the
+    red of the other, could reach it from inside the limits.
+    """
+    config = FitConfig(components=_components(**EISPAC), start="rest", backend=backend)
+    data, _, failed = fit_cube_gauss(_cube([_blend(velocity=-80.0)]), n_jobs=1,
+                                     fit_config=config, return_failed=True)
+    assert _velocity(data[0, 0]) == pytest.approx(-61.5, abs=0.05)
+    width = (data[0, 0, 2] * u.cm).to_value(u.AA)
+    assert 0.0191 - 1e-9 <= width <= 0.0510 + 1e-9
+
+
+@pytest.mark.parametrize("backend", ["scipy", "mpfit"])
+def test_limits_that_hold_the_truth_change_nothing_in_a_noiseless_fit(backend):
+    spectrum = _cube([_blend(velocity=20.0, ratio=0.2)])
+    fitted = {}
+    for name, settings in (("free", {}), ("limited", {"start": "rest"})):
+        limits = EISPAC if name == "limited" else {}
+        config = FitConfig(components=_components(**limits), backend=backend, **settings)
+        fitted[name] = fit_cube_gauss(spectrum, n_jobs=1, fit_config=config)[0][0, 0]
+    assert _velocity(fitted["limited"]) == pytest.approx(20.0, abs=1e-3)
+    assert np.allclose(fitted["limited"], fitted["free"], rtol=1e-5, atol=0.0)
+
+
+def test_a_rest_start_puts_each_component_at_its_rest_wavelength():
+    """A search finds the shifted blend; a rest start does not look, but stays within limits."""
+    spectrum = _blend(velocity=40.0, ratio=0.3)
+    wave = _wave().to_value(u.cm)
+    searched = _guess_multi_params(wave, spectrum, FitConfig(components=_components()))
+    rested = _guess_multi_params(wave, spectrum, FitConfig(components=_components(),
+                                                           start="rest"))
+    assert _velocity(searched) == pytest.approx(40.0, abs=30.0)
+    assert rested[1] == pytest.approx(STRONG.to_value(u.cm), rel=1e-12)
+    assert rested[4] == pytest.approx(FAINT.to_value(u.cm), rel=1e-12)
+
+    narrow = FitConfig(components=_components(width_limits=(0.05 * u.AA, 0.06 * u.AA),
+                                              velocity_limits=(10 * u.km / u.s,
+                                                               20 * u.km / u.s)),
+                       start="rest")
+    clipped = _guess_multi_params(wave, spectrum, narrow)
+    assert _velocity(clipped) == pytest.approx(10.0, rel=1e-9)
+    assert (clipped[2] * u.cm).to_value(u.AA) == pytest.approx(0.05, rel=1e-12)
+
+
+@pytest.mark.parametrize("settings, message", [
+    ({"start": "middle"}, "fitting.start must be 'search' or 'rest'"),
+    ({"components": [FitComponent(STRONG), FitComponent(
+        FAINT, tie_center=0, velocity_limits=(-60 * u.km / u.s, 60 * u.km / u.s))]},
+     "velocity_limits and tie_center"),
+    ({"components": [FitComponent(STRONG), FitComponent(
+        FAINT, tie_width=0, width_limits=(0.02 * u.AA, 0.05 * u.AA))]},
+     "width_limits and tie_width"),
+    ({"start": "rest", "components": []}, "only applied to multi-component fits"),
+])
+def test_what_cannot_apply_is_refused(settings, message):
+    with pytest.raises(ValueError, match=message):
+        FitConfig(**{"components": _components(), **settings})
+
+
+@pytest.mark.parametrize("limits", [
+    {"velocity_limits": (60 * u.km / u.s, -60 * u.km / u.s)},
+    {"velocity_limits": (-60 * u.AA, 60 * u.AA)},
+    {"velocity_limits": (-60 * u.km / u.s,)},
+    {"width_limits": (0 * u.AA, 0.05 * u.AA)},
+    {"width_limits": (0.02 * u.km / u.s, 0.05 * u.km / u.s)},
+])
+def test_limits_that_are_not_two_ordered_values_of_the_right_kind_are_refused(limits):
+    with pytest.raises(ValueError, match="must be two"):
+        FitComponent(STRONG, **limits)
+
+
+def test_a_configuration_file_gives_them_with_units(tmp_path):
+    from eclipse.main import _parse_fitting_config
+
+    text = """
+fitting:
+  start: rest
+  constrain_positive_intensity: true
+  components:
+    - wavelength: 195.119 angstrom
+      velocity_limits: [-60 km/s, 60 km/s]
+      width_limits: [0.019 angstrom, 0.051 angstrom]
+    - wavelength: 195.179 angstrom
+      tie_center: 0
+      tie_width: 0
+"""
+    config = _parse_fitting_config(yaml.safe_load(text))
+    assert config.start == "rest"
+    low, high = config.components[0].velocity_limits
+    assert low == -60 * u.km / u.s and high == 60 * u.km / u.s
+    assert config.components[0].width_limits[1] == 0.051 * u.AA
+
+
+def test_the_settings_are_kept_in_a_results_file(tmp_path):
+    config = FitConfig(components=_components(**EISPAC), start="rest")
+    save_results(tmp_path / "run.h5", {"config_objects": {"fit": config}})
+    restored = load_results(tmp_path / "run.h5")["config_objects"]["fit"]
+    assert restored.start == "rest"
+    assert restored.components[0].velocity_limits == EISPAC["velocity_limits"]
+    assert restored.components[0].width_limits == EISPAC["width_limits"]
+
+
+def test_a_results_file_from_before_the_settings_loads_as_it_was_run(tmp_path):
+    """Earlier runs searched and had no limits, which is what the settings give, without a warning."""
+    import json
+    import warnings
+
+    import h5py
+
+    from eclipse import results_file
+
+    config = FitConfig(components=_components())
+    path = save_results(tmp_path / "old.h5", {"instrument": "SWC"})
+    encoded = results_file._jsonable(config)
+    del encoded["fields"]["start"]
+    for component in encoded["fields"]["components"]:
+        del component["fields"]["velocity_limits"], component["fields"]["width_limits"]
+    with h5py.File(path, "r+") as f:
+        f.attrs["fit"] = json.dumps(encoded)
+        f.attrs["eclipse_order"] = json.dumps(["instrument", "fit"])
+    with warnings.catch_warnings(record=True) as seen:
+        warnings.simplefilter("always")
+        restored = load_results(path)["fit"]
+    assert not seen, [str(w.message) for w in seen]
+    assert repr(restored) == repr(config)
+
+
+def test_a_search_within_limits_stays_within_them():
+    """The comb search tries only shifts that keep a limited component within its limits."""
+    spectrum = _blend(velocity=-40.0, ratio=0.06, strong=1.0) + _blend(velocity=52.0, ratio=0.0,
+                                                                       strong=1.2, background=0)
+    config = FitConfig(components=_components(velocity_limits=(-60 * u.km / u.s,
+                                                                 0 * u.km / u.s)))
+    guess = _guess_multi_params(_wave().to_value(u.cm), spectrum, config)
+    assert -60.0 <= _velocity(guess) <= 0.0
+    assert _velocity(guess) == pytest.approx(-40.0, abs=10.0)
+
+
+@pytest.mark.parametrize("value", ["60 km/s", 60, ["-60 km/s", "60 kms"]])
+def test_a_mistyped_limit_in_a_configuration_file_says_what_it_should_be(value):
+    from eclipse.main import _parse_fitting_config
+
+    fitting = {"components": [{"wavelength": "195.119 angstrom", "velocity_limits": value},
+                              {"wavelength": "195.179 angstrom", "tie_center": 0}]}
+    with pytest.raises(ValueError, match="velocity_limits must be two"):
+        _parse_fitting_config({"fitting": fitting})
+
+
+def test_limits_set_after_a_component_is_made_are_read():
+    component = FitComponent(STRONG)
+    component.velocity_limits = (-10 * u.km / u.s, 10 * u.km / u.s)
+    component.width_limits = (0.02 * u.AA, 0.03 * u.AA)
+    rest = STRONG.to_value(u.cm)
+    assert component.centre_limits() == pytest.approx(
+        (rest * (1 - 10 / C_KM_S), rest * (1 + 10 / C_KM_S)), rel=1e-12)
+    assert component.sigma_limits() == pytest.approx((0.02e-8, 0.03e-8), rel=1e-12)

{eclipse-0.13.0 → eclipse-0.14.0}/tests/test_raster.py

@@ -134,7 +134,9 @@ def test_an_exposure_is_shared_between_the_snapshots_it_spans(tmp_path):
     # Within one snapshot's span.
     assert series.coverage(2 * u.s, 8 * u.s) == [(0, 1.0)]
     # A quarter in the first, three quarters in the second.
-    assert series.coverage(5 * u.s, 25 * u.s) == pytest.approx([(0, 0.25), (1, 0.75)])
+    shares = series.coverage(5 * u.s, 25 * u.s)
+    assert [index for index, _ in shares] == [0, 1]
+    assert [fraction for _, fraction in shares] == pytest.approx([0.25, 0.75])
     # The last snapshot lasts as long as the gap before it.
     assert series.coverage(40 * u.s, 50 * u.s) == [(2, 1.0)]
     for start, end in ((-1, 5), (45, 51), (5, 5)):