lime-stable 2.0.dev7__py3-none-any.whl → 2.0.dev8__py3-none-any.whl

lime/archives/read_fits.py

@@ -257,35 +257,44 @@ def check_fits_instructions(fits_source, online_provider=False):
     else:
         fits_reader = None
 
-    # # Check for url location for surveys function
-    # if online_provider:
-    #     if hasattr(UrlFitsSurvey, fits_source):
-    #         url_locator = getattr(UrlFitsSurvey, fits_source)
-    #     else:
-    #         raise LiMe_Error(f'Input {fits_source} does not have a url manager for LiMe could not be created.')
-    # else:
-    #     url_locator = None
-
     return fits_reader
 
-def load_txt(text_address):
+def load_txt(text_address, **kwargs):
 
     # Columns
-    out_array = np.loadtxt(text_address)
+    out_array = np.loadtxt(text_address, **kwargs)
 
-    # Transform foot comments as dictionary data
-    params_dict = {}
-    with open(text_address, "r") as f:
+    # File address
+    if not type(text_address).__name__ == "UploadedFile":
+        with open(text_address, "r") as f:
+            lines = f.readlines()
 
-        # Reverse loop while the lines start by a "#"
-        for line in reversed(f.readlines()):
-            line = line.strip()
-            if not line.startswith("#") or (line.startswith("# LiMe")):
-                break
+    # Uploaded file
+    else:
+        lines = text_address.getvalue().decode("utf-8").splitlines()
 
-            # Extract key-value pairs
-            key, value = line[1:].split(":", 1)  # Split at the first ':'
-            params_dict[key.strip()] = value.strip()
+    # Reverse loop over the lines
+    params_dict = {}
+    for line in reversed(lines):
+        line = line.strip()
+        if not line.startswith("#") or line.startswith("# LiMe"):
+            break
+        key, value = line[1:].split(":", 1)
+        params_dict[key.strip()] = value.strip()
+
+    # # Transform foot comments as dictionary data
+    # params_dict = {}
+    # with open(text_address, "r") as f:
+    #
+    #     # Reverse loop while the lines start by a "#"
+    #     for line in reversed(f.readlines()):
+    #         line = line.strip()
+    #         if not line.startswith("#") or (line.startswith("# LiMe")):
+    #             break
+    #
+    #         # Extract key-value pairs
+    #         key, value = line[1:].split(":", 1)  # Split at the first ':'
+    #         params_dict[key.strip()] = value.strip()
 
     return out_array, params_dict
 
@@ -362,10 +371,10 @@ class OpenFits:
 
         return
 
-    def parse_data_from_file(self, file_address, pixel_mask=None):
+    def parse_data_from_file(self, file_address, pixel_mask, **kwargs):
 
         # Read the fits data
-        wave_array, flux_array, err_array, header_list, fits_params = self.fits_reader(file_address)
+        wave_array, flux_array, err_array, header_list, fits_params = self.fits_reader(file_address, **kwargs)
         pixel_mask = pixel_mask if pixel_mask is not None else fits_params['pixel_mask']
 
         # Mask requested entries
@@ -441,10 +450,10 @@ class OpenFits:
         return fits_args
 
     @staticmethod
-    def text(file_address):
+    def text(file_address, **kwargs):
 
         # Read text file dividing the columns into the spectrum axis and the comments as its parameters
-        data_arr, params_dict = load_txt(file_address)
+        data_arr, params_dict = load_txt(file_address, **kwargs)
 
         # Unpack the columns into the spectrum axes
         wave_array, flux_array = data_arr[:, 0], data_arr[:, 1]
@@ -456,16 +465,13 @@ class OpenFits:
         # Convert strings to expected format
         params_dict['redshift'] = float(params_dict['redshift']) if 'redshift' in params_dict else None
         params_dict['norm_flux'] = float(params_dict['norm_flux']) if 'norm_flux' in params_dict else None
-        params_dict['id_label'] = params_dict['id_label'] if 'norm_flux' in params_dict else None
+        params_dict['id_label'] = params_dict['id_label'] if 'id_label' in params_dict else None
         params_dict['pixel_mask'] = mask_array
 
-        # metadata['units_wave'] = au.Unit(metadata['units_wave']) if 'units_wave' in metadata else au.Unit('AA')
-        # metadata['units_flux'] = au.Unit(metadata['units_flux']) if 'units_flux' in metadata else au.Unit('FLAM')
-
         return wave_array, flux_array, err_array, None, params_dict
 
     @staticmethod
-    def nirspec(fits_address, data_ext_list=1, hdr_ext_list=(0, 1), pixel_mask=None):
+    def nirspec(fits_address, data_ext_list=1, hdr_ext_list=(0, 1), **kwargs):
 
         """
 
@@ -503,7 +509,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def isis(fits_address, data_ext_list=0, hdr_ext_list=0, pixel_mask=None):
+    def isis(fits_address, data_ext_list=0, hdr_ext_list=0, **kwargs):
 
         """
 
@@ -548,7 +554,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def osiris(fits_address, data_ext_list=0, hdr_ext_list=0, pixel_mask=None):
+    def osiris(fits_address, data_ext_list=0, hdr_ext_list=0, **kwargs):
 
         """
 
@@ -593,7 +599,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def sdss(fits_address, data_ext_list=(1, 2), hdr_ext_list=(0), pixel_mask=None):
+    def sdss(fits_address, data_ext_list=(1, 2), hdr_ext_list=(0), **kwargs):
 
         """
 
@@ -645,7 +651,7 @@ class OpenFits:
         return wave_array, flux_array, err_array, header_list, params_dict
 
     @staticmethod
-    def manga(fits_address, data_ext_list=('WAVE', 'FLUX', 'IVAR'), hdr_ext_list=('FLUX'), pixel_mask=None):
+    def manga(fits_address, data_ext_list=('WAVE', 'FLUX', 'IVAR'), hdr_ext_list=('FLUX'), **kwargs):
 
         """
 
@@ -692,7 +698,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def muse(fits_address, data_ext_list=(1, 2), hdr_ext_list=1, pixel_mask=None):
+    def muse(fits_address, data_ext_list=(1, 2), hdr_ext_list=1, **kwargs):
 
         """
 
@@ -737,7 +743,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def megara(fits_address, data_ext_list=0, hdr_ext_list=(0, 1), pixel_mask=None):
+    def megara(fits_address, data_ext_list=0, hdr_ext_list=(0, 1), **kwargs):
 
         """
 
@@ -781,7 +787,7 @@ class OpenFits:
         return wave_array, flux_cube, err_cube, header_list, fits_params
 
     @staticmethod
-    def miri(fits_address, data_ext_list=(1,2), hdr_ext_list=(1), pixel_mask=None):
+    def miri(fits_address, data_ext_list=(1,2), hdr_ext_list=(1), **kwargs):
 
         """
 

lime/fitting/lines.py

@@ -608,7 +608,6 @@ class ProfileModelCompiler:
                 line.eqw = np.full(self.n_comps, np.nan)
                 line.eqw_err = np.full(self.n_comps, np.nan)
                 line.FWHM_p = np.full(self.n_comps, np.nan)
-                # line.sigma_thermal = np.full(self.n_comps, np.nan)
 
             # Check for negative -0.0 # TODO this needs a better place # FIXME -0.0 error
             if np.signbit(line.sigma_err[i]):
@@ -825,12 +824,6 @@ class LineFitting:
         line.intg_flux = areasArray.mean()
         line.intg_flux_err = areasArray.std()
 
-        # # Compute the integrated signal to noise # TODO is this an issue for absorptions
-        # amp_ref = line.peak_flux - line.cont
-        # if emission_check:
-        #     if amp_ref < 0:
-        #         amp_ref = line.peak_flux
-
         # Compute SN_r
         line.snr_line = signal_to_noise_rola(line.peak_flux - line.cont, line.cont_err, line.n_pixels)
         line.snr_cont = line.cont/line.cont_err
@@ -842,20 +835,14 @@ class LineFitting:
         else:
             line._narrow_check = False
 
-        # # Line width to the pixel below the continuum (or mask size if not happening) # TODO Lime2.0 skip all this if narrow
-        # idx_0 = compute_FWHM0(peakIdx, emis_flux, -1, cont_arr, emission_check)
-        # idx_f = compute_FWHM0(peakIdx, emis_flux, 1, cont_arr, emission_check)
-        #
-        # # Velocity calculations
-        # velocArray = c_KMpS * (emis_wave[idx_0:idx_f] - line.peak_wave) / line.peak_wave
-        # self.velocity_profile_calc(line, velocArray, emis_flux[idx_0:idx_f], cont_arr[idx_0:idx_f], emission_check)
+        # Velocity calculations
         if (line.n_pixels >= min_array_dim) and (line._narrow_check is False):
             self.velocity_profile_calc(line, peakIdx, emis_wave, emis_flux, cont_arr, emission_check, min_array_dim=min_array_dim)
 
         # Pixel velocity # TODO we are not using this one
         line.pixel_vel = c_KMpS * line.pixelWidth/line.peak_wave
 
-        # Equivalent width computation (it must be an 1d array to avoid conflict in blended lines) # TODO Lime2.0 put all this on its function
+        # Equivalent width computation (it must be an 1d array to avoid conflict in blended lines)
         lineContinuumMatrix = cont_arr + normalNoise
         eqwMatrix = areasArray / lineContinuumMatrix.mean(axis=1)
 

lime/io.py

@@ -569,10 +569,13 @@ def results_to_log(line, log, norm_flux):
 
             # Converting None entries to str (9 = group_label)
             if j == 9:
+
                 if param_value is None:
                     param_value = 'none'
 
-            # print(comp, param, param_value)
+                if line.sub_comps[i] is not None:
+                    param_value = line.sub_comps[i].group_label
+
             log.at[comp, param] = param_value
 
     return

lime/lime.toml

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

lime/observations.py

@@ -411,7 +411,8 @@ class Spectrum:
         return spec
 
     @classmethod
-    def from_file(cls, file_address, instrument, mask_flux_entries=None, **kwargs):
+    def from_file(cls, file_address, instrument, redshift=None, norm_flux=None, crop_waves=None, res_power=None,
+                  units_wave=None, units_flux=None, pixel_mask=None, id_label=None, wcs=None, **kwargs):
 
         """
 
@@ -446,13 +447,19 @@ class Spectrum:
         cls._fitsMgr = OpenFits(file_address, instrument, cls.__name__)
 
         # Load the scientific data from the file
-        fits_args = cls._fitsMgr.parse_data_from_file(cls._fitsMgr.file_address, mask_flux_entries)
+        fits_args = cls._fitsMgr.parse_data_from_file(cls._fitsMgr.file_address, pixel_mask, **kwargs)
 
-        # Update the parameters file parameters with the user parameters
-        obs_args = {**fits_args, **kwargs}
+        # Update the file parameters with the user parameters
+        input_args = dict(redshift=redshift, norm_flux=norm_flux, crop_waves=crop_waves, res_power=res_power,
+                            units_wave=units_wave, units_flux=units_flux, id_label=id_label, wcs=wcs)
+
+        if cls._fitsMgr.spectrum_check:
+            input_args.pop('wcs')
+
+        input_args = {**fits_args, **{k: v for k, v in input_args.items() if v is not None}}
 
         # Create the LiMe object
-        return cls(**obs_args)
+        return cls(**input_args)
 
     @classmethod
     def from_survey(cls, target_id, survey, mask_flux_entries=None, **kwargs):

lime/plotting/plots.py

@@ -657,9 +657,10 @@ def redshift_permu_evaluation(spectrum, z_infered, obs_wave_arr, theo_wave_arr,
     return
 
 
-def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=False, color_dict=theme.colors, show_central=True):
+def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=True, color_dict=theme.colors, show_central=True):
 
     # Security check for low selection
+    # TODO check this error crashing
     if y[idcs_mask[2]:idcs_mask[3]].size > 1:
 
         # Lower limit for the filled region
@@ -768,8 +769,8 @@ class Plotter:
     def _line_matching_plot(self, axis, bands, x, y, z_corr, redshift):
 
         # Open the bands file the bands
-        match_log = self._spec.retrieve.line_bands(ref_bands=bands, fit_cfg=None, instrumental_correction=False,
-                                                   adjust_central_band=False)
+        match_log = check_file_dataframe(bands)
+
         # Compute bands limits
         w3 = match_log.w3.values * (1 + redshift)
         w4 = match_log.w4.values * (1 + redshift)
@@ -1008,43 +1009,6 @@ class SpectrumFigures(Plotter):
                 in_ax.fill_between(wave_plot/z_corr, low_limit*z_corr, high_limit*z_corr, alpha=0.2,
                                    color=theme.colors['fade_fg'])
 
-            # # Include the detection bands
-            # if detection_band is not None:
-            #
-            #     detec_obj = getattr(self._spec.infer, detection_band)
-            #
-            #     if detec_obj.confidence is not None:
-            #
-            #         # Boundaries array for confidence intervals
-            #         bounds = np.array([0.0, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-            #
-            #         # Adjust color map to match lower detection limit to fg color
-            #         cmap = plt.get_cmap(theme.colors['mask_map'])
-            #         cmaplist = [cmap(i) for i in range(cmap.N)]
-            #         cmaplist[0] = theme.colors['fg']
-            #         cmap = colors.LinearSegmentedColormap.from_list('mcm', cmaplist, bounds.size-1)
-            #         norm = colors.BoundaryNorm(bounds * 100, cmap.N)
-            #
-            #         # Iterate through the confidence intervals and plot the step spectrum
-            #         for i in range(1, len(bounds)):
-            #             if i > 1:
-            #                 idcs = detec_obj(bounds[i-1]*100, confidence_max=bounds[i]*100)
-            #                 wave_nan, flux_nan = np.full(wave_plot.size, np.nan), np.full(flux_plot.size, np.nan)
-            #                 wave_nan[idcs], flux_nan[idcs] = wave_plot[idcs] / z_corr, flux_plot[idcs] * z_corr
-            #
-            #                 in_ax.step(wave_nan, flux_nan, label=label, where='mid', color=cmap(i-1))
-            #
-            #         # Color bar
-            #         sm = cm.ScalarMappable(cmap=cmap, norm=norm)
-            #         sm.set_array([])
-            #         cbar = plt.colorbar(sm, ax=in_ax)
-            #         cbar.set_label('Detection confidence %', rotation=270, labelpad=35)
-            #
-            #
-            #     else:
-            #         _logger.warning(f'The line detection bands confidence has not been calculated. They are not included'
-            #                         f' on plot.')
-
             # Show components
             if show_categories and self._spec.infer.pred_arr is not None:
 

lime/plotting/plots_interactive.py

@@ -1536,7 +1536,7 @@ class CubeInspection:
             self._ax0.set_ylim(self.axlim_dict['image_ylim'])
             self._ax1.set_xlim(self.axlim_dict['spec_xlim'])
 
-            if not self.maintain_y_zoom:
+            if self.maintain_y_zoom:
                 self._ax1.set_ylim(self.axlim_dict['spec_ylim'])
 
         else:

lime/retrieve/line_bands.py

@@ -0,0 +1,226 @@
+import logging
+import numpy as np
+import pandas as pd
+from lime.io import LiMe_Error
+from lime.transitions import Line
+
+
+_logger = logging.getLogger('LiMe')
+
+
+def pars_bands_conf(spec, bands, fit_conf, composite_lines, automatic_grouping=True):
+
+    # Use the input groups
+    if automatic_grouping is False:
+
+        # Get the the grouped lines
+        groups_dict = {} if fit_conf is False else {comp: group_label
+                                                   for comp, group_label in fit_conf.items()
+                                                   if comp.endswith(('_b', '_m'))}
+
+        # Limit the selection to the user lines
+        if composite_lines is not None:
+            groups_dict = {line: comps for line, comps in groups_dict.items() if line in composite_lines}
+
+    # Automatic group review
+    else:
+
+        # Check the input dataframe is sorted
+        if not np.all(np.diff(bands.wavelength) >= 0):
+            _logger.warning(f'The input bands table is not sorted. This can cause issues in the bands generation:'
+                            f'\n{bands["wavelength"]}')
+
+        # Get list all the line groups and their lines
+        if fit_conf:
+
+            line_list, group_lines = [], []
+            group_names, group_blended_check = [], []
+            for comp, group_label in fit_conf.items():
+                if comp.endswith(('_b', '_m')):
+
+                    # Homogeneous group
+                    if '_m' not in group_label:
+                        lines_i = group_label.split('+')
+                        groups_i = [True] * (len(lines_i) - 1) if comp[-2:] == '_b' else [False] * (len(lines_i) - 1)
+
+                    # Mixed group (merged child line in the blended parent group)
+                    else:
+                        lines_i, groups_i = [], []
+                        for i, line in enumerate(group_label.split('+')):
+                            if line[-2:] != '_m':       # Single line
+                                lines_i.append(line)
+                                groups_i.append(True)
+                            else:                       # Merged line
+                                sub_group_label = fit_conf.get(line)
+                                if sub_group_label:
+                                    items = sub_group_label.split('+')
+                                    lines_i += items
+                                    groups_i += [False] * len(items)
+                                else:
+                                    raise LiMe_Error(f'The merged line: "{line}" in grouped line: "{comp}={group_label}" '
+                                                     f'is not specified.\nPlease define a "{line}=LineA+LineB" '
+                                                     f'in your configuration file.')
+
+                        # Convert the sub_group_type to the relation
+                        groups_i = np.array(groups_i)
+                        groups_i = groups_i[:-1] != groups_i[1:]
+
+                    # Add the group is all lines (sorted) in current wavelength range
+                    idcs_i = bands.index.get_indexer(lines_i)
+                    if np.all(idcs_i > -1):
+                        group_names.append(comp)
+                        group_lines.append(bands.loc[bands.index.isin(lines_i)].index.to_numpy())
+                        group_blended_check.append(groups_i)
+                        line_list += lines_i
+
+            # Sort the input lines using line banbs table
+            line_list = bands.loc[bands.index.isin(line_list)].index
+            sub_bands = bands.loc[line_list]
+            lambda_arr = sub_bands['wavelength'].to_numpy()
+
+            # Array to keep track of lines which have been assigned:
+            assigned_lines = np.zeros(line_list.size).astype(bool)
+
+            # Compare the observed line groups
+            groups_dict = {}
+            if line_list.size > 1:
+
+                # Get limits of the bands on the spectrum wavelength range
+                w3_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_list, 'w3'].to_numpy())
+                w4_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_list, 'w4'].to_numpy())
+
+                # Generate binary matrix with the line bands location
+                wave_matrix = np.zeros((lambda_arr.size, spec.wave_rest.data.size))
+                cols = np.arange(wave_matrix.shape[1])
+                wave_matrix[(cols >= w3_arr[:, None]) & (cols <= w4_arr[:, None])] = 1
+
+                # Compute the decision matrix with the common pixels
+                decision_matrix = wave_matrix @ wave_matrix.T
+
+                # pixels_width = wave_matrix.sum(axis=1)
+                # blended_matrix = decision_matrix < np.ceil(pixels_width/3)[:, None]
+                # math_dict = dict(zip(line_arr, np.arange(line_arr.size)))
+
+                # Loop through the input groups to confirm the best match
+                for i, group in enumerate(group_names):
+
+                    # Diagnostic to establish the relation between the lines
+                    threshold = 2
+                    w3_arr = np.searchsorted(spec.wave_rest.data, bands.loc[group_lines[i], 'w3'].to_numpy())
+                    w4_arr = np.searchsorted(spec.wave_rest.data, bands.loc[group_lines[i], 'w4'].to_numpy())
+                    mu = (w3_arr + w4_arr) / 2
+                    sigma = (w4_arr - w3_arr) / 6
+                    delta_mu = np.diff(mu)
+                    sigma_avg = np.sqrt((sigma[:-1] ** 2 + sigma[1:] ** 2) / 2)
+                    R = delta_mu / sigma_avg
+                    resolvable = R > threshold
+
+                    match_group = True if np.all(resolvable == group_blended_check[i]) else False
+
+                    # Before saving group check that there are no more lines grouped in the observation
+                    if match_group:
+                        idcs_i = sub_bands.index.get_indexer(group_lines[i])
+                        if np.all(np.sum(decision_matrix[idcs_i, :] > 0, axis=1) == idcs_i.size):
+                            groups_dict[group] = fit_conf[group]
+                            assigned_lines[idcs_i] = True
+
+        # Invalid
+        else:
+            _logger.warning(f'The user requested automatic_grouping for the line transitions but the "fit_conf" is empty')
+
+    # Applyt the requested group changes
+    rename_dict, exclude_list= {}, []
+    group_dict, w3_dict, w4_dict = {}, {}, {}
+    for new_label, group_label in groups_dict.items():
+
+        component_list = np.unique([Line(x).core for x in group_lines[group_names.index(new_label)] if '_k-' not in x])
+        old_label = component_list[0]
+
+        # Only apply corrections if components are present
+        idcs_comps = bands.index.isin(component_list)
+        if np.sum(idcs_comps) == component_list.size:
+
+            # Save the modifications
+            rename_dict[old_label] = new_label
+            exclude_list += list(component_list)
+            w3_dict[new_label] = bands.loc[idcs_comps, 'w3'].min()
+            w4_dict[new_label] = bands.loc[idcs_comps, 'w4'].max()
+            group_dict[new_label] = group_label
+
+        # Check the line or the same group is already there
+        else:
+            low, high = spec.wave_rest.compressed()[[0, -1]]
+            check_arr = np.array([(low < Line(label).wavelength < high)[0] for label in component_list])
+
+            # Lines outside wavelength range
+            if np.all(~check_arr):
+                continue
+
+            # Check if lines outside range
+            else:
+                if 'group_label' in bands.columns:
+                    if not np.any(groups_dict[new_label] == bands.group_label):
+                        _logger.info(f'Line component "{old_label}" for configuration entry: '
+                                     f'"{new_label}={groups_dict[new_label]}" not found in lines table')
+                else:
+                    _logger.info(f'Missing line(s) "{np.setxor1d(bands.loc[idcs_comps].index.to_numpy(), component_list)}" '
+                                 f'for configuration entry: '
+                                 f'"{new_label}={groups_dict[new_label]}" in reference lines table')
+
+    # Warn in case some of the bands dont match the database:
+    if not set(exclude_list).issubset(bands.index):
+        _logger.info(f' The following blended or merged lines were not found on the input lines database:\n'
+                     f' - {list(set(exclude_list) - set(bands.index))}\n'
+                     f' - It is recommended that the merged/blended components follow the reference transitions labels.\n')
+
+    # Change the latex labels
+    for old_label, new_label in rename_dict.items():
+        line = Line(new_label, band=bands, fit_conf=groups_dict, update_latex=True)
+        bands.loc[old_label, 'latex_label'] = line.latex_label[0] if line.merged_check else '+'.join(line.latex_label)
+
+    # Change the indexes
+    bands.rename(index=dict(rename_dict), inplace=True)
+
+    # Remove components columns
+    bands.drop(exclude_list, errors='ignore', inplace=True)
+
+    # Add the group_label values
+    if 'group_label' not in bands.columns:
+        bands['group_label'] = 'none'
+    bands['group_label'] = pd.Series(bands.index.map(group_dict), index=bands.index).fillna(bands['group_label'])
+
+    # Change velocity limits
+    bands['w3'] = pd.Series(bands.index.map(w3_dict), index=bands.index).fillna(bands['w3'])
+    bands['w4'] = pd.Series(bands.index.map(w4_dict), index=bands.index).fillna(bands['w4'])
+
+    return
+
+# if np.all(idcs_i > -1):
+
+# # Logic for single, merged and blended lines
+# shared_pixels = decision_matrix[idcs_i[:-1], idcs_i[1:]]
+# if np.any(shared_pixels > 0):
+#     match_group =False
+#     # line_pixels = np.max(pixels_width[idcs_i])
+#     # diag_arr = resolvable
+#     #
+#     # obs_type = ['_b'] if np.all(diag_arr) else ['_m'] if np.all(~diag_arr) else None
+# else:
+#     match_group = False
+
+# Compare observed group versus user group
+
+# else:
+#
+#     # Lines not assigned before:
+#     if np.all(assigned_lines[idcs_i] == False):
+#
+#         # Group consists in blended merged lines: Assigned single merged
+#         if (group_name[-2:] == '_m') and np.any(diag_arr[:-1] & diag_arr[1:]):
+#             output_groups[group_name] = group_label
+#             assigned_lines[idcs_i] = True
+# # Get groups of common entries
+# from scipy.sparse import csr_matrix, csgraph
+# _, auto_labels = csgraph.connected_components(csgraph=csr_matrix(decision_matrix > 1), directed=False)
+# for labels, group in zip(line_arr, auto_labels):
+#     print(f"{labels}   {group}")

lime/transitions.py

@@ -185,7 +185,7 @@ def air_to_vacuum_function(wave_array, units_wave='AA'):
     return wave_array / (1 + 1e-6 * (287.6155 + 1.62887 * sigma2 + 0.01360 * np.square(sigma2)))
 
 
-def check_units_from_wave(line, str_ion, str_wave, bands, ref_bands=None):
+def check_units_from_wave(line, str_ion, str_wave, bands):
 
     # First the input database
     if bands is not None:
@@ -202,16 +202,14 @@ def check_units_from_wave(line, str_ion, str_wave, bands, ref_bands=None):
 
         # Convert to units
         units = au.Unit(units) if units is not None else units
-        # units = None if (units is None or np.isnan(units)) else au.Unit(units)
 
     else:
         wave, units = None, None
 
     # Second the reference database
     if (units is None) or (wave is None):
-        ref_bands = ref_bands if ref_bands is not None else _PARENT_BANDS
-        wave = pd_get(ref_bands, line, 'wavelength', nan_to_none=True)
-        units = pd_get(ref_bands, line, 'units_wave', nan_to_none=True)
+        wave = pd_get(_PARENT_BANDS, line, 'wavelength', nan_to_none=True)
+        units = pd_get(_PARENT_BANDS, line, 'units_wave', nan_to_none=True)
 
         # Convert to units
         units = au.Unit(units) if units is not None else units
@@ -229,10 +227,6 @@ def check_units_from_wave(line, str_ion, str_wave, bands, ref_bands=None):
             units = au_unit.bases[0]
             wave = au_unit.scale
 
-    # # Give preferences to the tabel values
-    # wave = wave_label if wave is None else wave
-    # units = units_label if units is None else units
-
     return wave, units
 
 
@@ -407,7 +401,7 @@ def latex_from_label(label, particle=None, wave=None, units_wave=None, kinem=Non
     #
 
 
-def label_composition(line_list, bands=None, default_profile=None, ref_bands=None):
+def label_composition(line_list, bands=None, default_profile=None):
 
     # Empty containers for the label componentes
     n_comps = len(line_list)
@@ -436,7 +430,7 @@ def label_composition(line_list, bands=None, default_profile=None, ref_bands=Non
         particle[i] = Particle.from_label(line_items[0])
 
         # Wavelength properties
-        wavelength[i], units_wave[i] = check_units_from_wave(line, line_items[0], line_items[1], bands, ref_bands)
+        wavelength[i], units_wave[i] = check_units_from_wave(line, line_items[0], line_items[1], bands)
 
         # Split the optional components: "H1_1216A_t-rec_k-0_p-g" -> {'t': 'rec', 'k': '0', 'p': 'g'} # TODO better do that with optional_comps
         comp_conf = {optC[0]: optC[2:] for optC in line_items[2:]}
@@ -765,25 +759,26 @@ class Particle:
 
 class Line:
 
-    def __init__(self, label, band=None, fit_conf=None, profile=None, cont_from_bands=True, z_line=None,
-                 update_latex=False, ref_bands=None, interpret=True):
+    def __init__(self, label, band=None, fit_conf=None, profile=None, update_latex=False):
 
-        # Label attributes
+        # Core attributes
         self.label = label
         self.mask = None
         self.latex_label = None,
         self.group_label, self.list_comps = None, None
+        self.sub_comps = None
 
         self.particle = None
         self.wavelength, self.units_wave = None, None
         self.blended_check, self.merged_check = False, False
 
+        # Transition components
         self.kinem = None
-        self.profile_comp = profile
-        self.transition_comp = None
         self.core = None
-
         self._ref_idx = None
+
+        self.transition_comp = None
+        self.profile_comp = profile
         self._p_type = None
         self._p_shape = None
 
@@ -802,7 +797,7 @@ class Line:
         self.alpha, self.beta = None, None
         self.alpha_err, self.beta_err = None, None
         self.frac, self.frac_err = None, None
-        self.z_line = z_line
+        self.z_line = None
         self.v_r, self.v_r_err = None, None
         self.pixel_vel = None
         self.sigma_vel, self.sigma_vel_err = None, None
@@ -822,71 +817,55 @@ class Line:
         self.pixelWidth = None
 
         # Extra checks
-        self._cont_from_adjacent = cont_from_bands
-        self._decimal_wave = False
+        # self._cont_from_adjacent = cont_from_bands
+        # self._decimal_wave = False
         self._narrow_check = False
 
-        # Interpret the line from the user reference
-        if interpret:
-            self._from_label(label, band, fit_conf, update_latex, ref_bands)
+        # Recover the line data from the input databases
+        self._get_containers_data(label,
+                                  _PARENT_BANDS if band is None else check_file_dataframe(band, copy_input=False),
+                                  fit_conf,
+                                  update_latex)
 
         return
 
     def __str__(self):
-
         return self.label
 
     def __repr__(self):
-
         return self.label
 
-    def _from_label(self, label, band=None, fit_conf=None, update_latex=False, ref_bands=None):
+    def __eq__(self, var):
+        return self.label == var if isinstance(var, str) else False
 
-        # If band is not provided use default database
-        if band is None:
-            band = _PARENT_BANDS
-        band = check_file_dataframe(band, copy_input=False)
+    def __hash__(self):
+        return hash(self.label)
+
+    def _get_containers_data(self, label, band=None, fit_conf=None, update_latex=False):
 
         # Infer label from log if input line is a wavelength
         self.label = check_line_in_log(label, band)
 
-        # Get label components
-        comps_list = self.label.split('_')
-        n_comps = len(comps_list)
-        if n_comps < 2:
-            raise LiMe_Error(f'The {self.label} the line label format is not recognized. '
-                             f'Please use a "Particle_WavelengthUnits" format.')
-
-        # Check the modularity      (only 2 comps)    (case b-6)
-        modularity_comp = comps_list[-1] if (comps_list[-1] == 'b') or (comps_list[-1] == 'm') else None
-        self._modularity_component(modularity_comp, fit_conf, band)
+        # Get the transitions involved on the line
+        self.line_group_review(fit_conf, band)
 
         # Review the components of the line
-        items = label_composition(self.list_comps, bands=band if isinstance(band, DataFrame) else None,
-                                  default_profile=self.profile_comp)
-        self.particle, self.wavelength, self.units_wave, self.kinem, self.profile_comp, self.transition_comp = items
+        components = label_composition(self.list_comps,
+                                       band if isinstance(band, DataFrame) else None,
+                                       self.profile_comp)
+        self.particle, self.wavelength, self.units_wave, self.kinem, self.profile_comp, self.transition_comp = components
 
         # Quick elements for the line profile
         self._p_shape, self._p_type = label_profiling(self.profile_comp)
 
-        # Index of the line closest to the one in label
-        if self.blended_check or self.merged_check:
-            wave_label, _label_units = check_units_from_wave(None, None, comps_list[1], None)
-            self._ref_idx = argmin(self.wavelength - wave_label)
-        else:
-            self._ref_idx = 0
-
-        # Core component definition
-        self.core = f'{comps_list[0]}_{comps_list[1]}'
-
         # Provide a bands from the log if possible
         self.mask = label_mask_assigning(self.label, band, self.blended_check, self.merged_check, self.core)
 
         # Check if there are masked pixels in the line
         self.pixel_mask = 'no' if fit_conf is None else fit_conf.get(f'{self.label}_mask', 'no')
 
-        # Check if the wavelength has decimal transition
-        self._decimal_wave = True if '.' in self.label else False
+        # Check sub-line components
+        self.sub_transitions(fit_conf, band)
 
         # Compute latex entry if necessary
         self.latex_label = np.atleast_1d(self._review_science_notation(band if isinstance(band, DataFrame) else None,
@@ -898,13 +877,14 @@ class Line:
     def from_log(cls, label, log=None, norm_flux=1):
 
         # Confirm we are not introducing a blended line which has been blended
-
         if label in log.index:
             measured_check = True
+
         elif (label[-2:] == '_b') and (label[:-2] in log.index):
             _logger.warning(f'Blended line {label} not found in log, reading {label[:-2]}')
             label = label[:-2]
             measured_check = True
+
         else:
             _logger.warning(f'Input line {label} not found in log')
             measured_check = False
@@ -932,7 +912,17 @@ class Line:
 
         return inline
 
-    def _modularity_component(self, modularity_label, fit_conf=None, bands_log=None):
+    def line_group_review(self, fit_conf=None, bands_log=None):
+
+        # Establish the components
+        comps_list = self.label.split('_')
+        n_comps = len(comps_list)
+        if n_comps < 2:
+            raise LiMe_Error(f'The {self.label} the line label format is not recognized. '
+                             f'Please use a "Particle_WavelengthUnits" format.')
+
+        # Check the line type
+        modularity_label = comps_list[-1] if (comps_list[-1] == 'b') or (comps_list[-1] == 'm') else None
 
         # Not a single line
         if modularity_label is not None:
@@ -951,10 +941,8 @@ class Line:
         group_label_cfg = None if fit_conf is None else fit_conf.get(self.label, None)
         group_label_frame = None if not isinstance(bands_log, pd.DataFrame) else pd_get(bands_log, self.label,
                                                                                         column='group_label', transform='none')
-
-        self.group_label = group_label_cfg if group_label_cfg is not None else group_label_frame
-
         # Confirm blended or merged
+        self.group_label = group_label_cfg if group_label_cfg is not None else group_label_frame
         self.blended_check = True if (self.group_label is not None) and (self.merged_check is False) else False
 
         # Recover the profile components
@@ -982,6 +970,15 @@ class Line:
         else:
             self.list_comps = [self.label]
 
+        # Core component definition
+        self.core = f'{comps_list[0]}_{comps_list[1]}'
+
+        # Index of core component
+        if self.blended_check or self.merged_check:
+            self._ref_idx = self.list_comps.index(self.core) if self.core in self.list_comps else 0
+        else:
+            self._ref_idx = 0
+
         return
 
     def _review_science_notation(self, bands, update_latex=False, decimals=None):
@@ -1074,6 +1071,16 @@ class Line:
         else:
             return idcs_bands
 
+    def sub_transitions(self, fit_cfg, bands):
+
+        self.sub_comps = [None] * len(self.list_comps)
+        if self.blended_check and fit_cfg:
+            for i, sub_stransition in enumerate(self.list_comps):
+                if sub_stransition[-2:] == '_m':
+                    self.sub_comps[i] = Line(sub_stransition, bands, fit_cfg)
+
+        return
+
     # def index_bands_orig(self, wavelength_array, redshift, merge_continua=True, just_band_edges=False):
     #
     #     if self.mask is None:

lime/workflow.py

@@ -10,10 +10,10 @@ from lmfit.models import PolynomialModel
 from lime.fitting.lines import LineFitting, signal_to_noise_rola, sigma_corrections, k_gFWHM, velocity_to_wavelength_band, profiles_computation, linear_continuum_computation
 from lime.tools import ProgressBar, join_fits_files, extract_wcs_header, pd_get, unit_conversion
 from lime.transitions import Line, air_to_vacuum_function, label_decomposition
+from lime.retrieve.line_bands import pars_bands_conf
 from lime.io import check_file_dataframe, check_file_array_mask, log_to_HDU, results_to_log, load_frame, LiMe_Error, check_fit_conf, _PARENT_BANDS
 from lime.fitting.redshift import RedshiftFitting
 from lime import __version__
-from scipy.sparse import csr_matrix, csgraph
 
 
 
@@ -341,296 +341,6 @@ def res_power_approx(wavelength_arr):
     return wavelength_arr/delta_lambda
 
 
-def get_merged_blended_lines(spec, bands, in_cfg, composite_lines):
-
-    # Get lines on the list
-    comps_dict = {} if in_cfg is False else {comp: group_label
-                                             for comp, group_label in in_cfg.items()
-                                             if comp.endswith(('_b', '_m'))}
-
-    # Limit the selection to the user lines
-    if composite_lines is not None:
-        comps_dict = {line: comps for line, comps in comps_dict.items() if line in composite_lines}
-
-    # # Determine the grouped lines
-    # key_cfg = f'{default_cfg_prefix}_line_fitting'
-    # default_dict = {} if key_cfg not in in_cfg else {comp: group_label
-    #                                                 for comp, group_label in in_cfg[key_cfg].items()
-    #                                                 if comp.endswith(('_b', '_m'))}
-    #
-    # key_cfg = f'{obj_cfg_prefix}_line_fitting'
-    # obj_dict =  {} if key_cfg not in in_cfg else{comp: group_label
-    #                                              for comp, group_label in in_cfg[key_cfg].items()
-    #                                              if comp.endswith(('_b', '_m'))}
-    #
-    # if len(default_dict) == 0 and len(obj_dict) == 0:
-    #     output_dict = fit_conf.copy()
-    # else:
-    #     output_dict = {**default_dict, **obj_dict}
-
-    # b_m_arr = np.array(list(output_dict.keys()))
-    # core_arr = np.array([s[:-2] for s in b_m_arr])
-    # unique_elements, counts = np.unique(core_arr, return_counts=True)
-    # repeated_lines = unique_elements[counts > 1]
-    #
-    # # Check each case individually
-    # for line in repeated_lines:
-    #     line_blended, line_merged = line + '_b', line + '_m'
-    #     default_b, default_m = line_blended in default_dict, line_merged in default_dict
-    #     obj_b, obj_m = line_blended in obj_dict, line_merged in obj_dict
-    #
-    #     # Object configuration has priority
-    #     if not (obj_b == obj_m):
-    #         output_dict.pop(line_blended if obj_b else line_merged)
-    #
-    #     # Try default configuration
-    #     elif not (default_b == default_m):
-    #         output_dict.pop(line_blended if default_b else line_merged)
-    #
-    #     # Solve the kinematics
-    #     else:
-    #
-    #         # Get components
-    #         comps = output_dict[line_blended].split('+')
-    #
-    #         # Check if more than one component is on the bands
-    #         df_comps = bands.loc[bands.index.isin(comps)]
-    #         if df_comps.index.size > 1:
-    #
-    #             # Set minimum number of pixels for the model solution in the bands
-    #             central_band = bands.loc[bands.index.isin(comps), 'w3':'w4'].to_numpy() * (1 + spec.redshift)
-    #             idcs_central = np.searchsorted(spec.wave, (central_band[:, 0].min(), central_band[:, 1].max()))
-    #             blended_check = idcs_central[1] - idcs_central[0] > (3 * len(comps))
-    #
-    #             # Print warning
-    #             _logger.info(f'The input configuration has merged and blended entries for {line}. '
-    #                          f'Automatic assignment as {"blended" if blended_check else "Merged"} ({line_blended if blended_check else line_blended}'
-    #                          f'={output_dict[line_blended if blended_check else line_blended]})')
-    #             output_dict.pop(line_blended if blended_check else line_blended)
-
-    # # Get candidate lines for grouping
-    # line_arr = [item for v in output_dict.values() for item in v.split('+')]
-    # line_arr = bands.loc[bands.index.isin(line_arr)].index
-    # lambda_arr = bands.loc[line_arr, 'wavelength'].to_numpy()
-    #
-    # # Generate the line - wavelength matrix with the line pixels width
-    # wave_matrix = np.zeros((lambda_arr.size, spec.wave_rest.data.size))
-    # w3_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w3'].to_numpy())
-    # w4_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w4'].to_numpy())
-    # cols = np.arange(wave_matrix.shape[1])
-    # wave_matrix[(cols >= w3_arr[:, None]) & (cols <= w4_arr[:, None])] = 1
-    # pixels_width = wave_matrix.sum(axis=1)
-    #
-    # # Get the decision matrix with the matching intervals
-    # decision_matrix = wave_matrix @ wave_matrix.T
-    # blended_matrix = decision_matrix < np.ceil(pixels_width/3)[:, None]
-    # math_dict = dict(zip(line_arr, np.arange(line_arr.size)))
-    #
-    # results_dict = {}
-    # for label, group_label in output_dict.items():
-    #     list_group = group_label.split('+')
-    #     if all(key in math_dict for key in list_group):
-    #         blended_group = True if label[-1] == 'b' else False
-    #         relations = np.array([blended_matrix[math_dict[i], math_dict[j]] for i, j in list(combinations(list_group, 2))])
-    #         if np.all(relations == blended_group):
-    #             print(f'Passess: {label}={group_label}')
-    #             results_dict[label] = group_label
-
-    return comps_dict
-
-
-
-
-
-# upper_triangle < (np.ceil(pixels_width/3)[:, None]=
-#
-#
-#     np.fill_diagonal(decision_matrix, 0)  # optional
-#
-#     # Step 2: Extract the upper triangle (excluding diagonal)
-#     upper_triangle = np.ma.masked_array(np.triu(decision_matrix, k=1), mask=np.tril(np.ones_like(decision_matrix), k=0).astype(bool)).astype(int)
-#
-#     # Step 3: Find (i, j) pairs with >1 shared steps
-#     rows_i, rows_j = np.where(upper_triangle > 1)
-#     edges = list(zip(line_arr[rows_i], line_arr[rows_j]))
-#
-#     matrix < thresholds[:, None]
-#
-#     # Step 3: Check if all values in each column satisfy the condition
-#     idcs_type = upper_triangle < np.ceil(pixels_width/3)[:, None]
-#     merged_idcs = np.all(idcs_type, axis=0)
-#     blended_idcs = np.all(~idcs_type, axis=0)
-#     #
-    # math_dict = dict(zip(line_arr, np.arange(line_arr.size)))
-    # for row in rows_j:
-    #     print(line_arr[row])
-    #
-    # for label, group_label in output_dict.keys():
-    #     list_group = group_label.split('+')
-    #     if len(list_group) == 2:
-    #         x_label, y_label = math_dict.get(list_group[0]), math_dict.get(list_group[1])
-    #         if (x_label is not None) and (y_label is not None):
-    #
-
-
-    # print(w3_arr)
-    # print(w4_arr)
-    #
-    # wave_matrix[w3_arr:w4_arr, :]
-    # # box_pixels =
-    # #
-    # # print(idcs_lines)
-    # lambda_arr = bands.index.isin(line_arr)
-    # wave_arr = spec.wave.data
-
-    # Generate matrices array
-
-    # b_m_arr = np.array(list(output_dict.keys()))
-    # core_arr = np.array([s[:-2] for s in b_m_arr])
-    # unique_elements, counts = np.unique(core_arr, return_counts=True)
-    # repeated_lines = unique_elements[counts > 1]
-    #
-    # # Check each case individually
-    # for line in repeated_lines:
-    #     line_blended, line_merged = line + '_b', line + '_m'
-    #     default_b, default_m = line_blended in default_dict, line_merged in default_dict
-    #     obj_b, obj_m = line_blended in obj_dict, line_merged in obj_dict
-    #
-    #     # Object configuration has priority
-    #     if not (obj_b == obj_m):
-    #         output_dict.pop(line_blended if obj_b else line_merged)
-    #
-    #     # Try default configuration
-    #     elif not (default_b == default_m):
-    #         output_dict.pop(line_blended if default_b else line_merged)
-    #
-    #     # Solve the kinematics
-    #     else:
-    #
-    #         # Get components
-    #         comps = output_dict[line_blended].split('+')
-    #
-    #         # Check if more than one component is on the bands
-    #         df_comps = bands.loc[bands.index.isin(comps)]
-    #         if df_comps.index.size > 1:
-    #
-    #             # Set minimum number of pixels for the model solution in the bands
-    #             central_band = bands.loc[bands.index.isin(comps), 'w3':'w4'].to_numpy() * (1 + spec.redshift)
-    #             idcs_central = np.searchsorted(spec.wave, (central_band[:, 0].min(), central_band[:, 1].max()))
-    #             blended_check = idcs_central[1] - idcs_central[0] > (3 * len(comps))
-    #
-    #             # Print warning
-    #             _logger.info(f'The input configuration has merged and blended entries for {line}. '
-    #                          f'Automatic assignment as {"blended" if blended_check else "Merged"} ({line_blended if blended_check else line_blended}'
-    #                          f'={output_dict[line_blended if blended_check else line_blended]})')
-    #             output_dict.pop(line_blended if blended_check else line_blended)
-    #
-    #
-    # return output_dict
-
-def pars_bands_conf(spec, bands, ref_bands, fit_conf, composite_lines, automatic_grouping=False):
-
-    # Get the the grouped lines
-    comps_dict = {} if fit_conf is False else {comp: group_label
-                                               for comp, group_label in fit_conf.items()
-                                               if comp.endswith(('_b', '_m'))}
-
-    # Limit the selection to the user lines
-    if composite_lines is not None:
-        comps_dict = {line: comps for line, comps in comps_dict.items() if line in composite_lines}
-
-    if automatic_grouping:
-
-        # Get candidate lines for grouping
-        line_arr = [item for v in comps_dict.values() for item in v.split('+')]
-        line_arr = bands.loc[bands.index.isin(line_arr)].index
-        lambda_arr = bands.loc[line_arr, 'wavelength'].to_numpy()
-
-        # Generate the line - wavelength matrix with the line pixels width
-        wave_matrix = np.zeros((lambda_arr.size, spec.wave_rest.data.size))
-        w3_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w3'].to_numpy())
-        w4_arr = np.searchsorted(spec.wave_rest.data, bands.loc[line_arr, 'w4'].to_numpy())
-        cols = np.arange(wave_matrix.shape[1])
-        wave_matrix[(cols >= w3_arr[:, None]) & (cols <= w4_arr[:, None])] = 1
-        pixels_width = wave_matrix.sum(axis=1)
-
-        # Get the decision matrix with the matching intervals
-        decision_matrix = wave_matrix @ wave_matrix.T
-        blended_matrix = decision_matrix < np.ceil(pixels_width/3)[:, None]
-        math_dict = dict(zip(line_arr, np.arange(line_arr.size)))
-
-        # Get groups of common entries
-        _, auto_labels = csgraph.connected_components(csgraph=csr_matrix(decision_matrix > 1), directed=False)
-        for labels, group in zip(line_arr, auto_labels):
-            print(f"{labels}   {group}")
-
-    # Loop through the lines on the list and review which changes are necessary
-    rename_dict, exclude_list= {}, []
-    group_dict, w3_dict, w4_dict = {}, {}, {}
-    for new_label, group_label in comps_dict.items():
-
-        component_list = np.unique([Line(x).core for x in group_label.split('+') if '_k-' not in x])
-        old_label = component_list[0]
-
-        # Only apply corrections if components are present
-        idcs_comps = bands.index.isin(component_list)
-        if np.sum(idcs_comps) == component_list.size:
-
-            # Save the modifications
-            rename_dict[old_label] = new_label
-            exclude_list += list(component_list)
-            w3_dict[new_label] = bands.loc[idcs_comps, 'w3'].min()
-            w4_dict[new_label] = bands.loc[idcs_comps, 'w4'].max()
-            group_dict[new_label] = group_label
-
-        # Check the line or the same group is already there
-        else:
-            low, high = spec.wave_rest.compressed()[[0, -1]]
-            check_arr = np.array([(low < Line(label).wavelength < high)[0] for label in component_list])
-
-            # Lines outside wavelength range
-            if np.all(~check_arr):
-                continue
-
-            # Check if lines outside range
-            else:
-                if 'group_label' in bands.columns:
-                    if not np.any(comps_dict[new_label] == bands.group_label):
-                        _logger.info(f'Line component "{old_label}" for configuration entry: '
-                                     f'"{new_label}={comps_dict[new_label]}" not found in lines table')
-                else:
-                    _logger.info(f'Missing line(s) "{np.setxor1d(bands.loc[idcs_comps].index.to_numpy(), component_list)}" '
-                                 f'for configuration entry: '
-                                 f'"{new_label}={comps_dict[new_label]}" in reference lines table')
-
-    # Warn in case some of the bands dont match the database:
-    if not set(exclude_list).issubset(bands.index):
-        _logger.info(f' The following blended or merged lines were not found on the input lines database:\n'
-                     f' - {list(set(exclude_list) - set(bands.index))}\n'
-                     f' - It is recommended that the merged/blended components follow the reference transitions labels.\n')
-
-    # Change the latex labels
-    for old_label, new_label in rename_dict.items():
-        line = Line(new_label, band=bands, fit_conf=comps_dict, update_latex=True)
-        bands.loc[old_label, 'latex_label'] = line.latex_label[0] if line.merged_check else '+'.join(line.latex_label)
-
-    # Change the indexes
-    bands.rename(index=dict(rename_dict), inplace=True)
-
-    # Remove components columns
-    bands.drop(exclude_list, errors='ignore', inplace=True)
-
-    # Add the group_label values
-    if 'group_label' not in bands.columns:
-        bands['group_label'] = 'none'
-    bands['group_label'] = pd.Series(bands.index.map(group_dict), index=bands.index).fillna(bands['group_label'])
-
-    # Change velocity limits
-    bands['w3'] = pd.Series(bands.index.map(w3_dict), index=bands.index).fillna(bands['w3'])
-    bands['w4'] = pd.Series(bands.index.map(w4_dict), index=bands.index).fillna(bands['w4'])
-
-    return
-
 
 class SpecRetriever:
 
@@ -641,7 +351,7 @@ class SpecRetriever:
         return
 
     def line_bands(self, band_vsigma=70, n_sigma=4, adjust_central_band=True, instrumental_correction=True, components_detection=False,
-               composite_lines=None, fit_cfg=None, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True,
+               composite_lines=None, automatic_grouping=False, fit_cfg=None, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True,
                line_list=None, particle_list=None, decimals=None, vacuum_waves=False, ref_bands=None, update_labels=False,
                update_latex=False, vacuum_label=False):
 
@@ -685,10 +395,10 @@ class SpecRetriever:
             bands['w3'] = (lambda_obs - delta_lambda) / (1 + self._spec.redshift)
             bands['w4'] = (lambda_obs + delta_lambda) / (1 + self._spec.redshift)
 
-        # Combine the blended/merged lines
+        # Combine the blended/merged lines in the bands table
         if fit_cfg is not None:
             in_cfg = check_fit_conf(fit_cfg, default_cfg_prefix, obj_cfg_prefix, update_default)
-            pars_bands_conf(self._spec, bands, ref_bands, in_cfg, composite_lines)
+            pars_bands_conf(self._spec, bands, in_cfg, composite_lines, automatic_grouping)
 
         # Filter the table to match the line detections
         if components_detection:
@@ -725,7 +435,7 @@ class SpecRetriever:
         frame = self._spec.frame if ref_frame is None else ref_frame
 
         # By default report complete spectrum
-        idcs = (0, -1)
+        idcs = (0, None)
 
         # If a line is provided get indexes for the bands limits
         line_measured = False
@@ -838,8 +548,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
         self._n_lines = 0
 
     def bands(self, label, bands=None, fit_cfg=None, min_method='least_squares', profile='g-emi', cont_from_bands=True,
-              err_from_bands=None, temp=10000.0, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True,
-              ref_bands=None):
+              err_from_bands=None, temp=10000.0, default_cfg_prefix='default', obj_cfg_prefix=None, update_default=True):
 
         """
 
@@ -911,7 +620,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
         cont_from_bands = True if cont_from_bands is None else cont_from_bands
 
         # Interpret the input line
-        self.line = Line(label, bands, input_conf, profile, cont_from_bands, ref_bands=ref_bands)
+        self.line = Line(label, bands, input_conf, profile, cont_from_bands)
 
         # Check the line selection is valid
         idcs_selection = review_bands(self._spec, self.line, user_cont_from_bands=cont_from_bands, user_err_from_bands=err_from_bands)
@@ -940,7 +649,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
                                  err_arr= pixel_err_arr[idcs_fitting],
                                  user_conf=input_conf, fit_method=min_method)
 
-            # Instrumental and thermal corrections for the lines # TODO make res_power array length of wave
+            # Instrumental and thermal corrections for the lines
             sigma_corrections(self.line, idcs_line, self._spec.wave[idcs_line], self._spec.res_power, temp)
 
             # Recalculate the SNR with the profile parameters
@@ -1081,7 +790,7 @@ class SpecTreatment(LineFitting, RedshiftFitting):
                         # Fit the lines
                         self.bands(line, bands, input_conf, min_method, profile,
                                    cont_from_bands=cont_from_bands, err_from_bands=err_from_bands,
-                                   temp=temp, obj_cfg_prefix=None, default_cfg_prefix=None, ref_bands=ref_bands)
+                                   temp=temp, obj_cfg_prefix=None, default_cfg_prefix=None)
 
                         if plot_fit:
                             self._spec.plot.bands()

{lime_stable-2.0.dev7.dist-info → lime_stable-2.0.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.dev7
+Version: 2.0.dev8
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@umich.edu>
 License-Expression: GPL-3.0-or-later

{lime_stable-2.0.dev7.dist-info → lime_stable-2.0.dev8.dist-info}/RECORD

@@ -1,24 +1,24 @@
 lime/__init__.py,sha256=i7iYJDoAYCsApb35OG33Y0repT6FpgLCsFMTk0Nu0rM,1279
 lime/changelog.txt,sha256=e02y8w_romtBvZLt7wrDxfL0Kry5ccTUkaajX_XwHbs,9657
-lime/io.py,sha256=9bH51m6DAYXJBLDXVQLmaOB0xw6_XoJiMoZlXDQ7Up4,32708
-lime/lime.toml,sha256=YZ4ISkDoWKzFX_o2XTfOzUGpZQvFYzH0ee1dkLaEcV4,52
-lime/observations.py,sha256=2XV1V7FsQYwi1plcGPHATNeLn-XccUhcKtzjds3D3YU,64552
+lime/io.py,sha256=J3oGfyznx-dqZCIY2tlTWBmuQzQEEJiBgU9Jpu-Sc9E,32778
+lime/lime.toml,sha256=oIJIPuAkwCzbGRKwY9gknhQRFHCyIcibg6BsC0yZd64,52
+lime/observations.py,sha256=BjzcfGi0VbzWUHw3DpME4AK3hxWaqC4fjt9bT1o_oxk,65018
 lime/tools.py,sha256=5E7_YeXeLrzFo-2h5EAI8J-cPaK4i6g6OJ1uL2jXJ7o,34136
-lime/transitions.py,sha256=-TgVCqL9R0-i4o8jHQGkGllHrMyP-Bo9DqoWfVNxHe4,45634
-lime/workflow.py,sha256=x3es6Sgq9wI785WdTsIuOWnWvKdSYdnJHN_MSkIhcxM,65417
+lime/transitions.py,sha256=9zxgUIgRRQIq1LFwiDSFYYdnMAppH-tENL6W2RIrw6Q,45639
+lime/workflow.py,sha256=7FqULLns2KKAlAf8AFQ_iEjMjts3k-Y3L1PLwVHubvQ,51784
 lime/archives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/archives/read_fits.py,sha256=TIJtP8iGokjE9Nj1ALYb7MHE2lUxZGHuz6cx5SZBb5U,37944
+lime/archives/read_fits.py,sha256=EifjLTsklZcrUAtCtuind5KWvDtEK_wMw_-5HA1P7l8,37928
 lime/archives/tables.py,sha256=sn3dINNorARuhEA_NsUKnhz8pT5d9u_sNBNKgv3EtuA,14242
 lime/fitting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lime/fitting/lines.py,sha256=X1QI9ZqpLfxvfVsOMWMDmwLxXhR_gNvIYBdFA7A2GD8,41288
+lime/fitting/lines.py,sha256=4WVw_auqLCCzftoxMJzhxYWJVqC1umcURWRq8kbScR8,40423
 lime/fitting/redshift.py,sha256=JBYQlESr63PrF3gRYVT-QLQr2yMi9YZKaeNxI8gFvgY,11639
 lime/inference/detection.py,sha256=m_Yz-53RGEvQQa6rgS_-nU2DwiRG45yuZIuneAvs0Dc,425
 lime/inference/intensity_threshold.py,sha256=9LqSjJQajfrM4SOHSqJWnverKFnrdrjnV472w56T79U,5047
 lime/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lime/plotting/bokeh_plots.py,sha256=xJlFS90NW-kQLSBDrfYd3tkjixyHK0DUs1vm5ExmjOQ,23444
 lime/plotting/format.py,sha256=KM2UjhfJ7j2iEOIRTn8JfpLNmSRSlUFTHqB5EKxTq80,7296
-lime/plotting/plots.py,sha256=LruFJvee0NcZ8wkMeb_-bMqonwLsgB6cF92aPqZRAOk,87496
-lime/plotting/plots_interactive.py,sha256=wX_ckpv_lM6YgZZFEfx36dfGt1DpTB5e-R3DyDkWgMY,73357
+lime/plotting/plots.py,sha256=hWyFL82U0UaTe6nspkhsEzMJqrZmz-Myck55wXvlPKE,85352
+lime/plotting/plots_interactive.py,sha256=9qj369eRBGI53qAvqAToUb4t1KqpSO4R_ZeGhovhwgg,73353
 lime/plotting/theme_lime.toml,sha256=moyNfRDx0x0Gma3azW_DNfLQoKd1qnBRiX0DAkioBbs,3396
 lime/plotting/utils.py,sha256=tPBXCvMlg7_onLWN9O2I7FoAurzkfF0Qe-JVYSLb1Xs,2069
 lime/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -27,9 +27,10 @@ lime/resources/lines_database_v2.0.0.txt,sha256=grhl32eDMtHHnXOw-LVmSCPbYjqUgccJ
 lime/resources/logo.py,sha256=buuJuwCjw0JFFtqvvIBpjb-LCuFgBwRFqnVOqCmSam8,3296
 lime/resources/types_params.txt,sha256=HgK-rr_cHnjNR3oLJomdYt6UvKwBn-FMWt40MkCR0wM,10111
 lime/retrieve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lime/retrieve/line_bands.py,sha256=QwcU5A2_4987q4JgIFF3p89r7pwQVlSlD4fSTZWwBpc,10595
 lime/retrieve/peaks.py,sha256=zERD2-GO-AtNrx8xwGqNbml0pB0nTCH4Oro-9fr69GU,8713
-lime_stable-2.0.dev7.dist-info/licenses/LICENSE.rst,sha256=B_kw459IXvKujLR27bhVUwXmTq9AM72DdCA1xGgBMKI,35608
-lime_stable-2.0.dev7.dist-info/METADATA,sha256=pvUxdCfhIskIQOvSpTUiTH4EQdn8ejTi_WiPfedg4ag,3931
-lime_stable-2.0.dev7.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-lime_stable-2.0.dev7.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
-lime_stable-2.0.dev7.dist-info/RECORD,,
+lime_stable-2.0.dev8.dist-info/licenses/LICENSE.rst,sha256=B_kw459IXvKujLR27bhVUwXmTq9AM72DdCA1xGgBMKI,35608
+lime_stable-2.0.dev8.dist-info/METADATA,sha256=cJ-MeAUOkn4CEF6tIqp8Ihn2fldgXMwssvI-Gcy3jII,3931
+lime_stable-2.0.dev8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lime_stable-2.0.dev8.dist-info/top_level.txt,sha256=F6pWR5Cgjf9EkXNBZlUSKFKcPG8vPzM08QwYFfwpsZc,5
+lime_stable-2.0.dev8.dist-info/RECORD,,

{lime_stable-2.0.dev7.dist-info → lime_stable-2.0.dev8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any