lime-stable 2.0.dev7__tar.gz → 2.0.dev8__tar.gz

{lime_stable-2.0.dev7/src/lime_stable.egg-info → lime_stable-2.0.dev8}/PKG-INFO

@@ -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 → lime_stable-2.0.dev8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.dev7"
+version = "2.0.dev8"
 readme = "README.rst"
 requires-python = ">=3.11"
 license = "GPL-3.0-or-later"

{lime_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/lime/lime.toml

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

{lime_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev7 → lime_stable-2.0.dev8}/src/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_stable-2.0.dev8/src/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}")