lime-stable 2.2.dev5__tar.gz → 2.4.0__tar.gz

{lime_stable-2.2.dev5/src/lime_stable.egg-info → lime_stable-2.4.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.2.dev5
+Version: 2.4.0
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@stsci.edu>
 License: GPL-3.0-or-later
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.rst
 Requires-Dist: astropy~=7.1
@@ -15,10 +15,9 @@ Requires-Dist: matplotlib~=3.10
 Requires-Dist: numpy~=2.3
 Requires-Dist: pandas~=2.2
 Requires-Dist: scipy~=1.16
-Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: aspect-stable~=0.7.dev2; extra == "full"
+Requires-Dist: aspect-stable~=0.8; extra == "full"
 Requires-Dist: bokeh~=3.8; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.2.dev5"
+version = "2.4.0"
 readme = { file = "README.md", content-type = "text/markdown" }
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license = {text = "GPL-3.0-or-later"}
 classifiers = ["License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
-               "Programming Language :: Python :: 3.11"]
+               "Programming Language :: Python :: 3.12"]
 
 authors = [{name = "Vital Fernández", email = "vgf@stsci.edu"}]
 description = "Line measuring algorithm for astronomical spectra"
@@ -19,12 +19,11 @@ dependencies = ["astropy~=7.1",
                 "matplotlib~=3.10",
                 "numpy~=2.3",
                 "pandas~=2.2",
-                "scipy~=1.16",
-                "tomli >= 2.0.0 ; python_version < '3.11'"]
+                "scipy~=1.16"]
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "aspect-stable~=0.7.dev2",
+        "aspect-stable~=0.8",
         "bokeh~=3.8",
         "mplcursors~=0.6",
         "openpyxl~=3.1",
@@ -48,3 +47,7 @@ mpl-results-path = 'tests/outputs'
 mpl-results-always = false
 markers = ["mpl: matplotlib image comparison tests"]
 addopts = "-p no:asdf_schema_tester"
+
+[tool.coverage.run]
+omit = ["src/lime/resources/generator_db.py",
+        "src/lime/resources/generator_logo.py"]

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/archives/tables.py

@@ -25,7 +25,7 @@ def format_for_table(entry, rounddig=4, rounddig_er=2, scientific_notation=False
         rounddig_er = rounddig
 
     # Check None entry
-    if entry != None:
+    if entry is not None:
 
         # Check string entry
         if isinstance(entry, (str, bytes)):

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/changelog.txt

@@ -122,4 +122,28 @@ LiMe minor update - 2.0.4 - 12/05/2025
     - Further development for the functions involving redshift a line fitting using aspect
     - The spatial masking functions should not require the 'PARAM', 'PARAMIDX', 'PARAMVAL' and 'NUMSPAXE' in the .fits headers to plot the mask overlays
 
+LiMe medium update - 2.4.0 - 26/06/2024
+    - Added new ultraviolet and infrared lines to the database `lines_database_v2.0.6.txt`
+    - Major updates to `observations.py`: expanded spectrum observation handling
+    - Major updates to `workflow.py`: significant refactoring of the fitting workflow
+    - The Transition and Line classes are been update to have an `origin`, `redshift` and `atomic_data` as attributes. This will be documented in a future major update
+    - Changes to the matplotlib and bokeh plot functions to use common theme structure
+    - The `Spectrum.retrieve.lines_frame` has been update to include an origin as an input. This will be documented in a future major update
+    - The `Spectrum.retrieve.lines_frame` documentation added to the API.
+    - Added SDSS complete spectrum example script (`3_complete_spectrum_SDSS.py`)
+    - Added line groups prediction example script (`3_line_groups_prediction.py`)
+    - Updated `fitting/redshift.py` function to correct a bug issue with non-line measurements
+    - Updated `archives/read_fits.py`: FITS reading improvements
+    - Updated `pyproject.toml` updated dependencies to include ASPECT features
+    - The computation of the line continua now takes into account the covariance of the fitting. The nominal values remain constant but the uncertainty predicted is smaller
+    - Expanded the tests for the latex/pdf table making functions from the `test_tables.py` script
+    - Expanded the tests to compare the line measurements with synthetic lines for more profile parameters (including the line continuum levels)
+    - Improvement of the descriptions in the measurements documentation page and correction of wrong terms
+    - Updated plot baselines across multiple tests
+    - Added paper citation on the documentation
+    - Added more integration with aspect functions (next medium release will focus on documenting these updgrades)
+    - Adding releases on the github page to mark medium / major updates
+    - Bump minimum python to 3.12 version for uniform requirements with readthedocs compilation
+
+
 

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/fitting/lines.py

@@ -1,5 +1,6 @@
 import logging
 
+import matplotlib.pyplot as plt
 import numpy as np
 from lmfit.models import Model
 from lmfit import fit_report
@@ -91,6 +92,7 @@ def const_cont_model(cont_array, prefix='cont_', allow_scale=False):
         # freeze at 1.0 -> truly constant
     return m, params
 
+
 def linear_model(x, m_cont, n_cont):
     """Linear line formulation"""
     return m_cont * x + n_cont
@@ -252,9 +254,9 @@ def power_area(line, idx, n_steps):
 def exp_area(line, idx, n_steps):
 
     amp = np.random.normal(line.amp[idx], line.amp_err[idx], n_steps)
-    alpha = np.random.normal(line.alpha[idx], line.alpha[idx], n_steps)
+    alpha = np.random.normal(line.alpha[idx], line.alpha_err[idx], n_steps)
 
-    return 2.5066282746 * amp * 1/alpha
+    return 2 * amp / alpha
 
 
 def pseudo_power_area(line, idx, n_steps):
@@ -938,9 +940,18 @@ class LineFitting:
         line.measurements.peak_wave = emis_wave[peakIdx]
         line.measurements.peak_flux = emis_flux[peakIdx]
         line.measurements.pixelWidth = np.diff(emis_wave).mean()
-        # line.measurements.cont = line.measurements.peak_wave * line.measurements.m_cont + line.measurements.n_cont
+
+        # Continuum level and uncertainty at peak
         line.measurements.cont = cont_arr[peakIdx]
-        line.measurements.cont_err = emis_err[peakIdx]
+
+        if self.cov_linear is None:
+            line.measurements.cont_err = np.sqrt(((emis_wave[-1] - emis_wave[peakIdx]) / (emis_wave[-1]-emis_wave[0]) * emis_err[0]) ** 2
+                                                 + ((emis_wave[peakIdx] - emis_wave[0]) / (emis_wave[-1]-emis_wave[0])  * emis_err[-1]) ** 2)
+        else:
+            line.measurements.cont_err = np.sqrt(self.cov_linear[0, 0] * emis_wave[peakIdx] ** 2 + self.cov_linear[1, 1]
+                                                 + 2 * self.cov_linear[0, 1] * emis_wave[peakIdx])
+
+        # y_val_err = np.sqrt(((emis_wave[-1] - emis_wave[peakIdx]) / (emis_wave[-1]-emis_wave[0]) * emis_err[0]) ** 2 + ((emis_wave[peakIdx] - emis_wave[0]) / (emis_wave[-1]-emis_wave[0])  * emis_err[-1]) ** 2)
 
         # Warning if continuum above or below line peak/through
         if emission_check and (cont_arr[peakIdx] > emis_flux[peakIdx]):
@@ -1003,61 +1014,67 @@ class LineFitting:
         match user_cont_source:
 
             case 'adjacent':
-
-                # Check for zero err
                 err_cont = self._spec.err_flux[idcs_cont].compressed() if self._spec.err_flux is not None else None
-                err_cont = err_cont if np.any(err_cont) else None
+                # err_cont = err_cont if np.any(err_cont) else None
 
                 # Fit the model, including uncertainties
-                params, covariance = curve_fit(linear_model,
-                                               xdata=self._spec.wave[idcs_cont].compressed(),
-                                               ydata=self._spec.flux[idcs_cont].compressed(),
-                                               sigma=err_cont,
-                                               absolute_sigma=True, check_finite=False)
-
-                self.line.measurements.m_cont, self.line.measurements.n_cont = params
-                self.line.measurements.m_cont_err_intg, self.line.measurements.n_cont_err_intg = np.sqrt(np.diag(covariance))
+                params, self.cov_linear = curve_fit(linear_model, xdata=self._spec.wave[idcs_cont].compressed(),
+                                                    ydata=self._spec.flux[idcs_cont].compressed(), sigma=err_cont,
+                                                    absolute_sigma=True, check_finite=False)
+
+                self.line.measurements.m_cont = params[0]
+                self.line.measurements.n_cont = params[1]
+                self.line.measurements.m_cont_err_intg, self.line.measurements.n_cont_err_intg = np.sqrt(np.diag(self.cov_linear))
+
                 cont_arr = self._spec.wave * self.line.measurements.m_cont + self.line.measurements.n_cont
 
             case 'central':
-
                 x, y = self._spec.wave[idcs_emis].compressed(), self._spec.flux[idcs_emis].compressed()
                 err = self._spec.err_flux[idcs_emis].compressed() if self._spec.err_flux is not None else [0, 0]
 
-                self.line.measurements.m_cont = (y[-1] - y[0]) / (x[-1] - x[0])
+                dx = x[-1] - x[0]
+                self.line.measurements.m_cont = (y[-1] - y[0]) / dx
                 self.line.measurements.n_cont =  y[0] - self.line.measurements.m_cont * x[0]
 
-                self.line.measurements.m_cont_err_intg = np.sqrt((err[0] * (-1 / (x[-1] - x[0]))) ** 2 + (err[-1] * (1/(x[-1] - x[0]))) ** 2)
-                self.line.measurements.n_cont_err_intg = np.sqrt(err[0] ** 2 + (self.line.measurements.m_cont_err_intg * (-x[0])) ** 2)
+                self.line.measurements.m_cont_err_intg = np.sqrt((err[0] / dx) ** 2 + (err[-1] / dx) ** 2)
+                self.line.measurements.n_cont_err_intg = np.sqrt((err[0] * x[-1] / dx) ** 2 + (err[-1] * x[0] / dx) ** 2)
+
                 cont_arr = self._spec.wave * self.line.measurements.m_cont + self.line.measurements.n_cont
 
-            case 'fit':
 
+            case 'fit':
                 x, y = self._spec.wave[idcs_cont].compressed(), self._spec.cont[idcs_cont].compressed()
                 err = self._spec.err_flux[idcs_cont].compressed() if self._spec.err_flux is not None else [0, 0]
 
-                self.line.measurements.m_cont = (y[-1] - y[0]) / (x[-1] - x[0])
+                dx = x[-1] - x[0]
+                self.line.measurements.m_cont = (y[-1] - y[0]) / dx
                 self.line.measurements.n_cont =  y[0] - self.line.measurements.m_cont * x[0]
 
-                self.line.measurements.m_cont_err_intg = np.sqrt((err[0] * (-1 / (x[-1] - x[0]))) ** 2 + (err[-1] * (1/(x[-1] - x[0]))) ** 2)
-                self.line.measurements.n_cont_err_intg = np.sqrt(err[0] ** 2 + (self.line.measurements.m_cont_err_intg * (-x[0])) ** 2)
+                self.line.measurements.m_cont_err_intg = np.sqrt((err[0] / dx) ** 2 + (err[-1] / dx) ** 2)
+                self.line.measurements.n_cont_err_intg = np.sqrt((err[0] * x[-1] / dx) ** 2 + (err[-1] * x[0] / dx) ** 2)
+
+                # TODO here with the uncertainty from the spectrum fitted
                 cont_arr = self._spec.cont
 
             case _:
                 raise LiMe_Error(f'Continuum source "{user_cont_source}" is not recognized. '
                                  f'Please use "central", "adjacent" and "fit".')
 
-        # # Initial continuum level value
-        # self.line.measurements.cont = (self.line.measurements.m_cont * self._spec.wave[idcs_emis].compressed().mean() +
-        #                                self.line.measurements.n_cont)
+        # Bands constant pixel error
+        if err_from_bands:
+            err_arr = self._spec.wave * 0 + np.std(self._spec.flux[idcs_cont] - (self.line.measurements.m_cont * self._spec.wave[idcs_cont] + self.line.measurements.n_cont), ddof=2)
+
+        # Spectrum error
+        else:
+            err_arr = self._spec.err_flux
 
-        return cont_arr
+        return cont_arr, err_arr
 
     def pixel_error_calculation(self, idcs_continua, user_error_from_bands):
-
+        # TODO delete this one
         # Constant pixel error array from adjacent bands
         if user_error_from_bands:
-            return np.ma.array(np.full(self._spec.wave.shape, np.std(self._spec.flux[idcs_continua] - (self.line.measurements.m_cont * self._spec.wave[idcs_continua] + self.line.measurements.n_cont))), mask=np.zeros(self._spec.wave.shape, dtype=bool))
+            return np.ma.array(np.full(self._spec.wave.shape, np.std(self._spec.flux[idcs_continua] - (self.line.measurements.m_cont * self._spec.wave[idcs_continua] + self.line.measurements.n_cont), ddof=2)), mask=self._spec.wave.mask)
 
         # Pixel array
         else:

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/fitting/redshift.py

@@ -134,7 +134,6 @@ def redshift_key_method(spec, bands, z_min, z_max, delta_z, pred_arr, components
 
         # If there is only one line return nan
         if not (method_flux and not detection_only):
-            # match np.count_nonzero(np.diff(np.r_[False, idcs_lines])):
             match comp_counter(idcs_lines):
                 case 0:
                     return None # No components

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/io.py

@@ -205,7 +205,7 @@ def load_cfg(file_address, fit_cfg_suffix='_line_fitting'):
     return cfg_lime
 
 
-def save_cfg(output_file, param_dict, section_name=None, clear_section=False):
+def save_cfg(output_file, param_dict, section_name=None, clear_section=False, overwrite_file=False):
 
     """
     This function safes the input dictionary into a configuration file. If no section is provided the input dictionary
@@ -224,7 +224,7 @@ def save_cfg(output_file, param_dict, section_name=None, clear_section=False):
             output_data = param_dict if section_name is None else {section_name: param_dict}
 
             # If the file does not exist create a new file
-            if not output_path.is_file():
+            if not output_path.is_file() or overwrite_file:
                 with open(output_file, "w") as f:
                     toml.dump(output_data, f)
 

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/lime.toml

@@ -1,6 +1,6 @@
 [metadata]
 name = 'lime-stable'
-version = "2.2.dev5"
+version = "2.4.0"
 
 # =====================
 # Spectrum / Long-slit

{lime_stable-2.2.dev5 → lime_stable-2.4.0}/src/lime/observations.py

@@ -161,12 +161,17 @@ def check_spectra_arrays(observation):
 
 def check_redshift_norm(redshift, norm_flux, flux_array, units_flux, norm_factor=1, min_flux_scale=0.001, max_flux_scale=1e50):
 
-    if (redshift is None) or np.isnan(redshift) or np.isinf(redshift):
+    if redshift is None:
         _logger.warning(f'No redshift provided for the spectrum. Assuming local universe observation (z = 0)')
         redshift = 0
 
-    if redshift < 0:
-        _logger.warning(f'Input spectrum redshift has a negative value: z = {redshift}')
+    elif not np.isfinite(redshift):
+        _logger.warning(f'The redshift value is no numeric: z={redshift}. Setting the value to z = 0)')
+        redshift = 0
+
+    else:
+        if redshift < 0:
+            _logger.warning(f'Input spectrum redshift has a negative value: z = {redshift}')
 
     if norm_flux is None:
         if units_flux.scale == 1:
@@ -950,6 +955,82 @@ class Spectrum:
 
     def save_spectrum(self, fname=None, line_label=None, ref_frame=None, split_components=False, **kwargs):
 
+        """Save or return the spectrum data, with the option to include the fitted profiles if available.
+
+        Exports the spectrum wavelength, flux, flux uncertainty, and pixel mask to a
+        space-delimited text file. If a ``line_label`` is provided and that line has
+        been measured, the output is cropped to the line band limits (``w1``–``w6``)
+        and the fitted profile(s) are appended as additional columns. The file footer
+        encodes key metadata (LiMe version, units, redshift, normalisation factor,
+        and object label) so the spectrum can be fully reconstructed using lime.Spectrum.from_file("file_address.txt", intrument="text")
+
+        If ``fname`` is ``None`` the data are returned as a NumPy record array instead
+        of being written to disk.
+
+        Parameters
+        ----------
+        fname : str or path-like, optional
+            Destination file path. If ``None`` (default) the spectrum is returned as
+            a :class:`numpy.recarray` rather than saved.
+        line_label : str, optional
+            Transition label (e.g. ``'H1_6563A'``) used to crop the output to the
+            band limits of that line and to append its fitted profile column(s). The
+            label must be present in ``ref_frame`` (or ``self.frame`` if
+            ``ref_frame`` is ``None``). If not found a warning is logged and the full
+            spectrum is saved without profile columns.
+        ref_frame : pandas.DataFrame, optional
+            Lines measurement frame to use for band limits and profile parameters.
+            Defaults to ``self.frame`` when ``None``.
+        split_components : bool, optional
+            When ``True`` and a ``line_label`` is supplied, each kinematic component
+            of the profile is written as a separate column (labelled by component
+            name). When ``False`` (default) all components are summed into a single
+            column labelled with ``line_label``.
+        **kwargs
+            Additional keyword arguments forwarded to :func:`numpy.savetxt`. Common
+            overrides include ``delimiter``, ``header``, and ``footer``. Defaults
+            are ``fmt`` (per-column format strings) and ``delimiter=' '``; any value
+            supplied here takes precedence.
+
+        Returns
+        -------
+        numpy.recarray or None
+            If ``fname`` is ``None``, returns a record array whose field names match
+            the output column headers (``wave``, ``flux``, ``err_flux``,
+            ``pixel_mask``, and optionally one or more profile columns). Columns that
+            are entirely ``NaN`` (e.g. ``err_flux`` when no uncertainty array is
+            attached) are dropped from the output. Returns ``None`` when writing to
+            a file.
+
+        Notes
+        -----
+        * Wavelengths are stored in the **observed** frame (rest-frame values
+          multiplied by ``1 + self.redshift``).
+        * Flux values are denormalised before saving (multiplied by
+          ``self.norm_flux``).
+        * Profile columns include the linear continuum contribution so that summing
+          them reconstructs the full fitted model over the band.
+        * The footer written by default uses a ``key:value`` format; do not supply a
+          custom ``footer`` kwarg unless you intend to replace this metadata block.
+
+        Examples
+        --------
+        Save the full spectrum to disk:
+
+        >>> spec.save_spectrum('my_spectrum.txt')
+
+        Return the band around ``H1_6563A`` as a record array:
+
+        >>> rec = spec.save_spectrum(line_label='H1_6563A')
+        >>> rec.dtype.names
+        ('wave', 'flux', 'err_flux', 'H1_6563A')
+
+        Save with individual kinematic components as separate columns:
+
+        >>> spec.save_spectrum('ha_components.txt', line_label='H1_6563A', split_components=True)
+        """
+
+
         # Headers for the default list
         headers = np.array(["wave", "flux", "err_flux", "pixel_mask"])
 
@@ -1164,6 +1245,67 @@ class Spectrum:
 
         return
 
+    def __repr__(self):
+
+        # Label
+        label_str = self.label if self.label is not None else 'Spectrum'
+
+        # Redshift and normalization
+        z_str = f'{self.redshift:.6f}' if self.redshift is not None else 'None'
+        norm_str = f'{self.norm_flux:.3e}' if self.norm_flux is not None else 'None'
+
+        # Wavelength range and resolution
+        if self.wave is not None:
+            wmin_str = f'{self.wave.data.min():.2f}'
+            wmax_str = f'{self.wave.data.max():.2f}'
+            delta = np.diff(self.wave.data)
+            if np.all(np.isclose(delta, delta[0])):
+                res_str = f'constant ({delta[0]:.3f} {self.units_wave})'
+            else:
+                res_str = f'variable (min={delta.min():.3f}, max={delta.max():.3f} {self.units_wave})'
+        else:
+            wmin_str = wmax_str = res_str = 'None'
+
+        # Resolving power
+        if self.res_power is None:
+            res_power_str = 'None'
+        elif np.ndim(self.res_power) == 0:
+            res_power_str = f'{self.res_power:.1f} (scalar)'
+        else:
+            res_power_arr = np.asarray(self.res_power)
+            if np.all(np.isclose(res_power_arr, res_power_arr[0])):
+                res_power_str = f'{res_power_arr[0]:.1f} (constant)'
+            else:
+                res_power_str = f'variable (min={res_power_arr.min():.1f}, max={res_power_arr.max():.1f})'
+
+        # Checks
+        has_mask = (self.wave is not None) and np.any(self.wave.mask)
+        has_err = self.err_flux is not None
+
+        return (
+            f'\n{"=" * 60}\n'
+            f'  {label_str}\n'
+            f'{"=" * 60}\n'
+            f'  Units\n'
+            f'    Wavelength   : {self.units_wave}\n'
+            f'    Flux         : {self.units_flux}\n'
+            f'{"-" * 60}\n'
+            f'  Observation\n'
+            f'    Redshift     : {z_str}\n'
+            f'    Norm flux    : {norm_str}\n'
+            f'{"-" * 60}\n'
+            f'  Wavelength grid\n'
+            f'    wmin         : {wmin_str} {self.units_wave}\n'
+            f'    wmax         : {wmax_str} {self.units_wave}\n'
+            f'    Resolution   : {res_str}\n'
+            f'    Res. power   : {res_power_str}\n'
+            f'{"-" * 60}\n'
+            f'  Checks\n'
+            f'    Masked pixels     : {"yes" if has_mask else "no"}\n'
+            f'    Uncertainty array : {"yes" if has_err else "no"}\n'
+            f'{"=" * 60}\n'
+        )
+
 
 class Cube: