lime-stable 2.0.dev3__tar.gz → 2.0.dev6__tar.gz

{lime_stable-2.0.dev3/src/lime_stable.egg-info → lime_stable-2.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev3
+Version: 2.0.dev6
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later
@@ -19,7 +19,7 @@ Requires-Dist: aspect-stable~=0.3.1
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: bokeh~=3.6; extra == "full"
+Requires-Dist: bokeh~=3.7; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"
 Requires-Dist: PyLaTeX~=1.4; extra == "full"

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.dev3"
+version = "2.0.dev6"
 readme = "README.rst"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"
@@ -25,7 +25,7 @@ classifiers = ["Programming Language :: Python :: 3",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "bokeh~=3.6",
+        "bokeh~=3.7",
         "mplcursors~=0.6",
         "openpyxl~=3.1",
         "PyLaTeX~=1.4",

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/__init__.py

@@ -42,7 +42,7 @@ _logger.debug(f'Launching LiMe {__version__} in Python {__python_version__}')
 from lime.observations import Spectrum, Sample, Cube
 from lime.io import *
 from lime.tools import *
-from lime.transitions import Line, label_decomposition, bands_from_frame
+from lime.transitions import Line, label_decomposition, bands_from_measurements
 from lime.archives.read_fits import OpenFits, show_instrument_cfg
 from lime.plotting.plots import theme
 from lime.workflow import line_bands

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/archives/read_fits.py

@@ -154,7 +154,7 @@ def check_fits_source(fits_source, lime_object=None, load_function=None):
     else:
 
         if load_function is None:
-            raise LiMe_Error(f'Please introduce fits file instrument or a load function to import the fits file as a '
+            _logger.warning(f'Please introduce fits file instrument or a load function to import the fits file as a '
                              f'LiMe observation')
 
     return fits_source, spectrum_type

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/archives/tables.py

@@ -122,6 +122,9 @@ def table_fluxes(lines_df, table_address, header_format_latex, table_type='pdf',
         except:
             print('\n-- PDF compilation failure')
 
+    elif table_type == 'tex':
+        pdf.pdfDoc.generate_tex(table_address.as_posix())
+
     return
 
 

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/changelog.txt

@@ -105,4 +105,9 @@ LiMe Mayor update - 2.0.0 - XX/XX/XXXX
     - The central wavelenght bands are now calculated assuming a bands_vsigma=70 and n_sigma=4
     - The function lime.Spectrum.retrieve.spectrum() returns the spectrum axes as a recarray or saves it into a text file if the user provides a file address.
     - lime.Spectrum.from_file("fname", instrument='text') can now read the file from a text file following the format from the lime.Spectrum.retrieve.spectrum() function.
-    - Bug the .plot.spectrum(include_fittings) does not show the combined profile
+    - Bug the .plot.spectrum(include_fittings) does not show the combined profile
+    - Rename term "_conf" to "_cfg" across function names and arguments for uniformity
+    - Fitting functions now have the update_default=True argument. In the default behaviour the default configuration updates the default one. If set to update_default=False only the obj_cfg is used if available else the default one.
+    - Creating a spectrum object where all the entries are masked now produces a critical warning instead of raising an error.
+    - By default line_bands.
+    - Added bands_from_log function

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/fitting/lines.py

@@ -180,7 +180,6 @@ def pp_FWHM(line, idx):
 
 
 def gaussian_area(line, idx, n_steps):
-
     amp = np.random.normal(line.amp[idx], line.amp_err[idx], n_steps)
     sigma = np.random.normal(line.sigma[idx], line.sigma_err[idx], n_steps)
 
@@ -418,7 +417,9 @@ def sigma_corrections(line, idcs_line, wave_arr, R_arr, temperature):
         if np.isscalar(R_arr):
             line.sigma_instr = np.mean(wave_arr.compressed() / (R_arr * k_gFWHM))
         else:
-            line.sigma_instr = np.mean(wave_arr[idcs_line].compressed() / (R_arr[idcs_line] * k_gFWHM))
+            mask_data = ~wave_arr.mask
+            line.sigma_instr = np.mean(wave_arr[mask_data] / (R_arr[idcs_line][mask_data] * k_gFWHM))
+            wave_arr[mask_data] / (R_arr[idcs_line][mask_data] * k_gFWHM)
     else:
         line.sigma_instr = np.nan
 
@@ -468,8 +469,6 @@ class ProfileModelCompiler:
         self.model.prefix = f'line0_'
 
         # Fix or not the continuum
-        # m_cont_conf = _SLOPE_FIX_PAR if line._cont_from_adjacent else _SLOPE_FREE_PAR
-        # n_cont_conf = _INTER_FIX_PAR if line._cont_from_adjacent else _INTER_FREE_PAR
         self.define_param(0, line, 'm_cont', line.m_cont, _SLOPE_FIX_PAR, user_conf)
         self.define_param(0, line, 'n_cont', line.n_cont, _INTER_FIX_PAR, user_conf)
 
@@ -614,8 +613,11 @@ class ProfileModelCompiler:
             # Check for negative -0.0 # TODO this needs a better place # FIXME -0.0 error
             if np.signbit(line.sigma_err[i]):
                 line.sigma_err[i] = np.nan
-                if self.output.errorbars:
-                    _logger.warning(f'Negative value for profile sigma at {line.label}')
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
+
+            if np.signbit(line.amp_err[i]):
+                line.amp_err[i] = np.nan
+                _logger.warning(f'Negative scale value for amplitude at {comp_label}')
 
             # Compute the profile areas
             profile_flux_dist = AREA_FUNCTIONS[line._p_shape[i]](line, i, 1000)

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/fitting/redshift.py

@@ -283,6 +283,9 @@ class RedshiftFitting:
             else:
                 pred_arr, conf_arr = self._spec.infer.pred_arr, self._spec.infer.conf_arr
 
+        # Resolving power # TODO this should be read at another point...
+        res_power = self._spec.res_power if res_power is None else res_power
+
         # Set the type of fitting and the components to use
         if mode == 'key':
             components = components if components is not None else ['emission', 'doublet']

lime_stable-2.0.dev6/src/lime/inference/intensity_threshold.py

@@ -0,0 +1,137 @@
+import logging
+
+import numpy as np
+import pandas as pd
+
+from scipy import signal
+from lime.io import check_file_dataframe
+from lime.transitions import label_decomposition
+from lime.plotting.plots import plot_peaks_troughs
+
+try:
+    import joblib
+    joblib_check = True
+except ImportError:
+    joblib_check = False
+
+
+_logger = logging.getLogger('LiMe')
+
+MACHINE_PATH = None
+FLUX_PIXEL_CONV = np.linspace(0,1,33)
+
+
+def compute_line_width(idx_peak, spec_flux, delta_i, min_delta=2, emission_check=True):
+
+    """
+    Algororithm to measure emision line width given its peak location
+    :param idx_peak:
+    :param spec_flux:
+    :param delta_i:
+    :param min_delta:
+    :return:
+    """
+
+    i = idx_peak
+
+    if emission_check:
+        while (spec_flux[i] > spec_flux[i + delta_i]) or (np.abs(idx_peak - (i + delta_i)) <= min_delta):
+            i += delta_i
+    else:
+        while (spec_flux[i] < spec_flux[i + delta_i]) or (np.abs(idx_peak - (i + delta_i)) <= min_delta):
+            i += delta_i
+
+    return i
+
+
+
+
+class LineFinder:
+
+    def __init__(self):
+
+        return
+
+    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5,
+                       continuum_array=None, continuum_std=None, plot_steps=False, **kwargs):
+
+        """
+
+        This function compares the input lines bands in the observation spectrum to confirm the presence of lines.
+
+        The input bands can be specified as a pandas dataframe or the path to its file via the ``bands_df`` argument.
+
+        The continuum needs to be fit a priori with the Spectrum.fit.continuum function or assigning a ``continuum_array``
+        and a ``continuum_std``.
+
+        The ``sigma_threshold`` establishes the standard deviation factor beyond which a positive line detection is assumed.
+
+        By default the algorithm seeks for emission lines, set ``emission_type`` equal to False for absorption lines.
+
+        The additional arguments provide additional utils to adjust the line detection and show the steps/results.
+
+        :param bands: Input bands dataframe or the address to its file.
+        :type bands: pandas.Dataframe, str, pathlib.Path
+
+        :param sigma_threshold: Continuum standard deviation factor for line detection. The default value is 3.
+        :type sigma_threshold: float, optional
+
+        :param emission_type: Line type. The default value is "True" for emission lines.
+        :type emission_type: str, optional
+
+        :param width_tol: Minimum number of pixels between peaks/troughs. The default value is 5.
+        :type width_tol: float, optional
+
+        :param ml_detection: Machine learning algorithm to detect lines. The default value is None.
+        :type ml_detection: str, optional
+
+        :param plot_steps: Plot the detected peaks/troughs. The default value is False
+        :type plot_steps: bool, optional
+
+        """
+
+        # TODO Lime2.0 replace by warning with new retrieve line bands
+        # Check for the peaks of the emission lines
+        continuum_array = self._spec.cont if continuum_array is None else continuum_array
+        continuum_std = self._spec.cont_std if continuum_std is None else continuum_std
+
+        # Get indeces of peaks
+        limit_threshold = sigma_threshold * continuum_std
+        limit_threshold = continuum_array + limit_threshold if emission_type else continuum_array + limit_threshold
+        idcs_peaks, _ = signal.find_peaks(self._spec.flux, height=limit_threshold, distance=width_tol)
+
+        # Match peaks with theoretical lines
+        bands = check_file_dataframe(bands)
+        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, line_type=emission_type)
+
+        # Plot the results
+        if plot_steps:
+            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, **kwargs)
+
+        return matched_DF
+
+
+    def label_peaks(self, idcs_peaks, matched_DF, line_type='emission', width_tol=5):
+
+        # Security check in case no lines detected
+        if len(idcs_peaks) == 0:
+            return pd.DataFrame(columns=matched_DF.columns)
+
+        # Add theoretical wavelength values if necessary
+        if 'wavelength' not in matched_DF.columns:
+            matched_DF['wavelength'] = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
+
+        # Get bands limits indexes
+        idcs_w3 = np.searchsorted(self._spec.wave_rest, matched_DF.w3)
+        idcs_w4 = np.searchsorted(self._spec.wave_rest, matched_DF.w4)
+
+        # Get the bands matching
+        band_contains_peak = (idcs_peaks[None, :] > idcs_w3[:, None]) & (idcs_peaks[None, :] < idcs_w4[:, None])
+        idcs_matched_bands = band_contains_peak.any(axis=1)
+        idcs_matched_peaks = idcs_peaks[band_contains_peak.argmax(axis=1)[idcs_matched_bands]]
+
+        # Crop the bands to the detection
+        matched_DF.loc[idcs_matched_bands, 'observation'] = 'detected'
+        matched_DF.loc[idcs_matched_bands, 'signal_peak'] = idcs_matched_peaks
+
+        return matched_DF.loc[idcs_matched_bands]

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/io.py

@@ -446,8 +446,8 @@ def save_frame(fname, dataframe, page='FRAME', parameters='all', header=None, co
                 output_file.write(string_DF.encode('UTF-8'))
 
         # Pdf fluxes table
-        elif file_type == '.pdf':
-            table_fluxes(lines_log, log_path.parent / log_path.stem, header_format_latex=_LOG_COLUMNS_LATEX,
+        elif file_type == '.pdf' or  file_type == '.tex':
+            table_fluxes(lines_log, log_path.parent / log_path.stem, table_type=file_type[1:],  header_format_latex=_LOG_COLUMNS_LATEX,
                          lines_notation=log.latex_label.values, **kwargs)
 
         # Log in a fits format
@@ -601,7 +601,8 @@ def check_file_dataframe(df_variable, variable_type=pd.DataFrame, ext='FRAME', s
     return output
 
 
-def check_fit_conf(fit_conf, default_key, group_key, group_list=None, fit_cfg_suffix='_line_fitting', line_detection=False):
+def check_fit_conf(fit_conf, default_key, obj_key, update_default=True, group_list=None, fit_cfg_suffix='_line_fitting',
+                   line_detection=False):
 
     # Check that there is an input configuration
     if fit_conf is not None:
@@ -634,33 +635,30 @@ def check_fit_conf(fit_conf, default_key, group_key, group_list=None, fit_cfg_su
 
         # Recover the configuration expected for the object
         default_cfg = input_cfg.get(f'{default_key}_line_fitting') if default_key is not None else None
-        mask_cfg = input_cfg.get(f'{group_key}_line_fitting') if group_key is not None else None
+        custom_cfg = input_cfg.get(f'{obj_key}_line_fitting') if obj_key is not None else None
 
-        # Case there are not leveled entries
-        if (default_cfg is None) and (mask_cfg is None):
+        # Case there are not level entries
+        if (default_cfg is None) and (custom_cfg is None):
             output_cfg = input_cfg
 
         # Proceed to update the levels
         else:
 
             # Default configuration
-            output_cfg = {} if default_cfg is None else default_cfg
-            default_detect = output_cfg.get('line_detection')
+            default_cfg = {} if default_cfg is None else default_cfg
+            default_detect = default_cfg.get('line_detection', {})
 
-            # Mask conf
-            mask_conf = {} if mask_cfg is None else mask_cfg
-            mask_detect = mask_conf.get('line_detection')
+            # Custom configuration
+            custom_cfg = {} if custom_cfg is None else custom_cfg
+            custom_detect = custom_cfg.get('line_detection', {})
 
-            # Update the levels
-            output_cfg = {**output_cfg, **mask_conf}
+            # Update default configuration if requested else use only custom
+            output_cfg = {**default_cfg, **custom_cfg} if update_default else (custom_cfg if custom_cfg else default_cfg)
 
-            # If no line detection don't add it # TODO this is wrong lower should update upper
-            if mask_detect is not None:
-                output_cfg['line_detection'] = mask_detect
-            elif default_detect is not None:
-                output_cfg['line_detection'] = default_detect
-            else:
-                pass
+            # Update default detection if requested else use only custom
+            if line_detection:
+                output_cfg['line_detection'] = default_detect.update(custom_detect) if update_default else\
+                                                                    (custom_detect if custom_detect else default_detect)
 
     else:
         output_cfg = {}

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/lime.toml

@@ -1,3 +1,3 @@
 [metadata]
 name = 'lime-stable'
-version = "2.0.dev3"
+version = "2.0.dev6"

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/observations.py

@@ -142,7 +142,7 @@ def check_inputs_arrays(wave, flux, err_flux, pixel_mask, lime_object):
     # Check not all the pixels are masked
     if mask_check:
         if np.all(output_pixel_mask):
-            raise LiMe_Error(f'All the input observation pixels are masked. Please check that only bad pixels entries'
+            _logger.critical(f'All the input observation pixels are masked. Please check that only bad pixels entries'
                              f' are masked (in numpy arrays flux_arr[pixel_mask] = bad_entries)')
 
     return output_pixel_mask
@@ -1347,6 +1347,8 @@ class Sample(UserDict, OpenFits):
         else:
             obs = load_function_output
 
+
+
         return obs
 
     def __getitem__(self, id_key):

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/plotting/bokeh_plots.py

@@ -102,14 +102,7 @@ def bokeh_bands(fig, bands, x, y, z_corr, redshift):
 
     # Loop through the detections and plot the names
     for i in np.arange(latex.size):
-        if idcs_band_limits[0, i] != idcs_band_limits[0, i]:  # Y limit for the label check if same pixel
-            max_region = np.max(y[idcs_band_limits[0, i]:idcs_band_limits[0, i]])
-        else:
-            max_region = y[idcs_band_limits[0, i]]
-
-        label = 'Matched line' if i == 0 else '_'
         fig.add_layout(BoxAnnotation(left=w3_obs[i]/z_corr, right=w4_obs[i]/z_corr, fill_alpha=0.3, fill_color=theme.colors['match_line']))
-        # axis.text(wave_array[i] * (1 + redshift) / z_corr, max_region * 0.9 * z_corr, latex[i], rotation=270)
 
     return
 
@@ -193,8 +186,8 @@ class BokehFigures:
 
         return
 
-    def bands(self, label, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, log_scale=True, fig_cfg=None,
-              ax_cfg=None, return_fig=False):
+    def bands(self, label, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, log_scale=True,
+              exclude_continua=True, fig_cfg=None, ax_cfg=None, return_fig=False):
 
 
         # Unpack variables
@@ -232,16 +225,13 @@ class BokehFigures:
             # Create figure with default utils if not provided
             fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"), y_axis_type=scale_str)
 
-            # # Create figure with default utils if not provided
-            # fig = figure(tools=PLT_CONF.get('tools', "pan,wheel_zoom,box_zoom,reset,save"))
-
             # Spectrum data source
             source = ColumnDataSource(data={"x": wave_plot[idcs_bands[0]:idcs_bands[5]] / z_corr,
                                             "y": flux_plot[idcs_bands[0]:idcs_bands[5]] * z_corr})
             fig.step("x", "y", source=source, color=theme.colors['fg'], line_width=1, mode='center')
 
             # Fille the bands
-            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line)
+            bands_filling_bokeh(fig, wave_plot, flux_plot, z_corr, idcs_bands, line, exclude_continua=exclude_continua)
 
             # Plot labels
             fig.xaxis.axis_label = AXES_CONF['xlabel']
@@ -250,6 +240,9 @@ class BokehFigures:
             # Adjust the format of the plot
             update_bokeh_figure(fig, PLT_CONF)
 
+            # Hide the legend if there are line profiles
+            fig.legend.visible = legend_check
+
             # Save or display the plot
             if return_fig:
                 return fig
@@ -258,11 +251,14 @@ class BokehFigures:
                 save(fig, filename=output_address)
 
             else:
-                # output_notebook()
                 show(fig)
 
+        else:
+            _logger.info(f'The input line {label} could not be found')
+
         return
 
+
     def grid(self, output_address=None, rest_frame=True, log_scale=False, n_cols=6, n_rows=None, col_row_scale=(2, 1.5),
              include_fits=True, in_fig=None, fig_cfg=None, ax_cfg=None, maximize=False):
 
@@ -270,7 +266,7 @@ class BokehFigures:
 
     def spectrum(self, output_address=None, label=None, bands=None, rest_frame=False, log_scale=False,
                  include_fits=True, include_cont=False, include_components=False, return_fig=False, fig_cfg=None, ax_cfg=None, maximize=False,
-                 detection_band=None, show_masks=True, show_categories=False):
+                 detection_band=None, show_masks=True, show_categories=False, show_err=False):
 
 
         # Set figure format with the user inputs overwriting the default conf
@@ -298,6 +294,14 @@ class BokehFigures:
         if bands is not None:
             bokeh_bands(fig, bands, wave_plot, flux_plot, z_corr, self._spec.redshift)
 
+        # Show uncertainty
+        if show_err and (self._spec.err_flux is not None):
+            err_plot = self._spec.err_flux.data
+            fig.varea_step(x=wave_plot / z_corr,
+                           y1=(flux_plot - err_plot) * z_corr,
+                           y2=(flux_plot + err_plot) * z_corr,
+                           step_mode="center", fill_alpha=0.2, color=theme.colors['err_area'])
+
         # Include the continuum
         if include_cont and self._spec.cont is not None:
             fig.line(wave_plot/z_corr, self._spec.cont*z_corr, legend_label="Continuum.",
@@ -402,6 +406,9 @@ class BokehFigures:
         # Adjust the format of the plot
         update_bokeh_figure(fig, PLT_CONF)
 
+        # Hide the legend if there are line profiles
+        fig.legend.visible = legend_check
+
         # Save or display the plot
         if return_fig:
             return fig

{lime_stable-2.0.dev3 → lime_stable-2.0.dev6}/src/lime/plotting/format.py

@@ -54,6 +54,7 @@ class Themer:
         self.conf = None        # All the formating data
         self.style = None       # Label of the active style
         self.active_conf = None   # Dictionary with the active figure configuration and library
+        self.default_lib = 'matplotlib'
 
         # LiMe plots personalization
         self.colors = None      # Features individual colors
@@ -67,6 +68,8 @@ class Themer:
         self.conf = conf.copy()
         self.set_style(style)
 
+
+
         return
 
 
@@ -163,7 +166,7 @@ class Themer:
         return ax_cfg
 
 
-    def set_style(self, style=None, scale=None, colors_conf=None, library=None):
+    def set_style(self, style=None, scale=None, colors_conf=None, library='matplotlib'):
 
         # Set the default style
         # self.style = ['default']
@@ -173,6 +176,7 @@ class Themer:
         #     self.style += [style] if isinstance(style, str) else style
         self.style = 'default' if style is None else style
         self.scale = ['default'] if style is None else [scale]
+        self.default_lib = library
 
         # Set the library defaults
         self.active_conf = {'matplotlib': self.conf['matplotlib']['default'].copy(),