lime-stable 2.0.dev3__py3-none-any.whl → 2.0.dev4__py3-none-any.whl

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/changelog.txt

@@ -105,4 +105,8 @@ 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

lime/fitting/lines.py

@@ -418,7 +418,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
 

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/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/lime.toml

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

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/plotting/bokeh_plots.py

@@ -270,7 +270,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 +298,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.",

lime/plotting/plots.py

@@ -654,7 +654,7 @@ 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):
+def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=False, color_dict=theme.colors, show_central=True):
 
     # Security check for low selection
     if len(x[idcs_mask[2]:idcs_mask[3]]) > 1:
@@ -673,8 +673,9 @@ def bands_filling_plot(axis, x, y, z_corr, idcs_mask, label, exclude_continua=Fa
             low_lim = m * x_interval + n
 
         # Central bands
-        axis.fill_between(x_interval/z_corr, low_lim*z_corr, y_interval*z_corr,
-                          facecolor=color_dict['line_band'], step='mid', alpha=0.25)
+        if show_central:
+            axis.fill_between(x_interval/z_corr, low_lim*z_corr, y_interval*z_corr,
+                              facecolor=color_dict['line_band'], step='mid', alpha=0.25)
 
         # Continua bands exclusion
         if exclude_continua is False:
@@ -767,8 +768,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_conf=None, instrumental_correction=False,
-                                                   adjust_central_bands=False)
+        match_log = self._spec.retrieve.line_bands(ref_bands=bands, fit_cfg=None, instrumental_correction=False,
+                                                   adjust_central_band=False)
         # Compute bands limits
         w3 = match_log.w3.values * (1 + redshift)
         w4 = match_log.w4.values * (1 + redshift)
@@ -782,6 +783,7 @@ class Plotter:
 
         # Loop through the detections and plot the names
         for i, line_label in enumerate(match_log.index):
+            print(line_label)
             line = Line(line_label, match_log)
 
             # Get the max flux on the region making the exception for 1 pixel bands
@@ -1274,7 +1276,7 @@ class SpectrumFigures(Plotter):
         return in_fig
 
     def bands(self, label=None, output_address=None, ref_bands=None, include_fits=True, rest_frame=False, y_scale='auto', fig_cfg=None,
-              ax_cfg=None, in_fig=None, maximize=False):
+              ax_cfg=None, in_fig=None, maximize=False, show_err=True):
 
         """
 
@@ -1333,6 +1335,12 @@ class SpectrumFigures(Plotter):
         # Check which line should be plotted
         line = parse_bands_arguments(label, log, ref_bands, norm_flux)
 
+        # Check the observation has uncertainty to display
+        if show_err and (self._spec.err_flux is None):
+            if self._spec.err_flux is None:
+                _logger.info('Input observation does not include uncertainty to display')
+                show_err = False
+
         # Proceed to plot
         if line is not None:
 
@@ -1375,7 +1383,14 @@ class SpectrumFigures(Plotter):
                               where='mid', color=theme.colors['fg'], label=label_leg, linewidth=theme.plt['spectrum_width'])
 
                 # Continuum bands
-                bands_filling_plot(in_ax[0], wave_plot, flux_plot, z_corr, idcs_bands, line, color_dict=theme.colors)
+                bands_filling_plot(in_ax[0], wave_plot, flux_plot, z_corr, idcs_bands, line, color_dict=theme.colors,
+                                   show_central=not show_err)
+
+                if show_err:
+                    err_plot = self._spec.err_flux.data
+                    in_ax[0].fill_between(x=wave_plot[idcs_bands[2]:idcs_bands[3]] / z_corr, y1=(flux_plot[idcs_bands[2]:idcs_bands[3]] - err_plot[idcs_bands[2]:idcs_bands[3]]) * z_corr,
+                                       y2=(flux_plot[idcs_bands[2]:idcs_bands[3]] + err_plot[idcs_bands[2]:idcs_bands[3]]) * z_corr,
+                                       step='mid', alpha=1, color=theme.colors['line_band'], ec=None)
 
                 # Add the fitting results
                 if include_fits:

lime/plotting/plots_interactive.py

@@ -20,23 +20,31 @@ from ..transitions import label_decomposition, Line
 _logger = logging.getLogger('LiMe')
 
 
-def establish_selection_lines(spec, input_log, band_vsigma=70, n_sigma=4, fit_conf=None,
-                             default_conf_prefix='default', obj_conf_prefix=None, adjust_central_bands=True,
-                             instrumental_correction=True, components_detection=False, line_list=None,
-                             particle_list=None, sig_digits=None, vacuum_waves=False, ref_bands=None, update_labels=True,
-                             update_latex=False):
+def establish_selection_lines(spec, input_log, band_vsigma, n_sigma, adjust_central_band, instrumental_correction,
+                              components_detection, composite_lines, fit_cfg, default_cfg_prefix, obj_cfg_prefix,
+                              update_default, line_list, particle_list, decimals, vacuum_waves, ref_bands, update_labels,
+                              update_latex, vacuum_label):
 
     # Use the default database crop for the observation if none provided
-    ref_bands = spec.retrieve.line_bands(band_vsigma, n_sigma, None, None, None,
-                   adjust_central_bands, instrumental_correction, False, line_list,
-                   particle_list, sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+    ref_bands = spec.retrieve.line_bands(band_vsigma=band_vsigma, n_sigma=n_sigma, adjust_central_band=adjust_central_band,
+                                         instrumental_correction=instrumental_correction, components_detection=False,
+                                         composite_lines=None, fit_cfg=None, default_cfg_prefix=None,
+                                         obj_cfg_prefix=None, update_default=True,
+                                         line_list=line_list, particle_list=particle_list, decimals=decimals,
+                                         vacuum_waves=vacuum_waves, ref_bands=ref_bands, update_labels=update_labels,
+                                         update_latex=update_latex, vacuum_label=vacuum_label)
+
 
     # Load input log or copy the reference one
     in_bands = check_file_dataframe(input_log, verbose=False)
     if in_bands is None:
-        in_bands = spec.retrieve.line_bands(band_vsigma, n_sigma, fit_conf, default_conf_prefix, obj_conf_prefix,
-                               adjust_central_bands, instrumental_correction, components_detection, line_list,
-                               particle_list, sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+        in_bands = spec.retrieve.line_bands(band_vsigma=band_vsigma, n_sigma=n_sigma, adjust_central_band=adjust_central_band,
+                                         instrumental_correction=instrumental_correction, components_detection=components_detection,
+                                         composite_lines=composite_lines, fit_cfg=fit_cfg, default_cfg_prefix=default_cfg_prefix,
+                                         obj_cfg_prefix=obj_cfg_prefix, update_default=update_default,
+                                         line_list=line_list, particle_list=particle_list, decimals=decimals,
+                                         vacuum_waves=vacuum_waves, ref_bands=ref_bands, update_labels=update_labels,
+                                         update_latex=update_latex, vacuum_label=vacuum_label)
         default_status = 1 if components_detection else 0
     else:
         default_status = 1
@@ -78,6 +86,11 @@ def establish_selection_lines(spec, input_log, band_vsigma=70, n_sigma=4, fit_co
     active_lines = active_lines[sorted_indexes].astype(bool)
     labels_arr = labels_arr[sorted_indexes]
 
+    # Set NaN entries in dataframe as None
+    if 'group_label' in log.columns:
+        idcs_nan = log.group_label.isnull()
+        log.loc[idcs_nan, 'group_label'] = 'none'
+
     return log, labels_arr,  active_lines
 
 
@@ -180,17 +193,20 @@ class BandsInspection:
         self._color_bg = {True: theme.colors['inspection_positive'],
                           False: theme.colors['inspection_negative']}
 
+        self._out_params = ["wavelength", "wave_vac", "w1", "w2", "w3", "w4", "w5", "w6",
+                            "units_wave", "particle", "transition", "rel_int"]
+
         return
 
-    def bands(self, bands_file, band_vsigma=70, n_sigma=4, fit_conf=None, default_conf_prefix='default', obj_conf_prefix=None,
-              adjust_central_bands=True, instrumental_correction=True, components_detection=False, line_list=None,
-              particle_list=None, sig_digits=None, vacuum_waves=False, ref_bands=None, update_labels=True,
-              update_latex=False, y_scale='auto', n_cols=6, n_rows=None, col_row_scale=(1, 0.5),
-              exclude_continua=False,  n_pixels=10, fig_cfg=None, in_fig=None, maximize=False):
+    def bands(self, bands_file, 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, line_list=None, particle_list=None, decimals=None,
+              vacuum_waves=False, ref_bands=None, update_labels=False, update_latex=False, vacuum_label=False,
+              y_scale='auto', n_cols=6, n_rows=None, col_row_scale=(1, 0.5),
+              exclude_continua=False, n_pixels=10, fig_cfg=None, in_fig=None, maximize=False):
 
 
         """
-
         This function launches an interactive plot from which to select the line bands on the observed spectrum. If this
         function is run a second time, the user selections won't be overwritten.
 
@@ -266,10 +282,11 @@ class BandsInspection:
                     raise LiMe_Error(f'Input bands file directory does not exist ({self._log_address.parent.as_posix()})')
 
         # Establish the reference lines log to inspect the mask
-        self.log, self.line_list, self.active_lines = establish_selection_lines(self._spec, self._log_address,  band_vsigma, n_sigma, fit_conf,
-                                                        default_conf_prefix, obj_conf_prefix, adjust_central_bands,
-                                                        instrumental_correction, components_detection, line_list, particle_list,
-                                                        sig_digits, vacuum_waves, ref_bands, update_labels, update_latex)
+        self.log, self.line_list, self.active_lines = establish_selection_lines(self._spec, self._log_address,
+                                                      band_vsigma, n_sigma, adjust_central_band, instrumental_correction,
+                                                      components_detection, composite_lines, fit_cfg, default_cfg_prefix,
+                                                      obj_cfg_prefix, update_default, line_list, particle_list, decimals,
+                                                      vacuum_waves, ref_bands, update_labels, update_latex, vacuum_label)
 
         # Proceed if there are lines in the mask for the object spectrum wavelength range
         if len(self.log.index) > 0:
@@ -430,7 +447,7 @@ class BandsInspection:
                     _logger.info(f'Unsuccessful line selection: {self.line}: w_low: {w_low}, w_high: {w_high}')
 
             # Save the log to the file
-            save_or_clear_log(self.log, self._log_address, self.active_lines)
+            save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
             # Redraw the line measurement
             self._ax.clear()
@@ -470,7 +487,7 @@ class BandsInspection:
                 self.active_lines[idx] = np.invert(self.active_lines[idx])
 
             # Save the log to the file
-            save_or_clear_log(self.log, self._log_address, self.active_lines)
+            save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
             # Plot the line selection with the new Background
             self._ax.clear()
@@ -516,7 +533,7 @@ class BandsInspection:
         self._fig.canvas.draw()
 
         # Save the log to the file
-        save_or_clear_log(self.log, self._log_address, self.active_lines)
+        save_or_clear_log(self.log, self._log_address, self.active_lines, self._out_params)
 
         return
 
@@ -821,8 +838,12 @@ class RedshiftInspection:
 
     def redshift(self, obj_idcs, reference_lines, output_file_log=None, output_idcs=None, redshift_column='redshift',
                  initial_z=None, none_value=np.nan, unknown_value=0.0,  legend_handle='levels', maximize=False, title=None,
-                 output_address=None, n_pixels=10, fig_cfg={}, ax_cfg={}, in_fig=None):
+                 output_address=None, n_pixels=10, fig_cfg={}, ax_cfg={}, in_fig=None, **kwargs):
+
 
+        # Check if input tuple
+        if isinstance(obj_idcs, tuple):
+            obj_idcs = pd.MultiIndex.from_tuples([obj_idcs], names=self._sample.index.names)
 
         # Assign the attributes
         self._obj_idcs = obj_idcs if isinstance(obj_idcs, pd.MultiIndex) else self._sample.loc[obj_idcs].index
@@ -833,6 +854,10 @@ class RedshiftInspection:
         self._legend_handle = legend_handle
         self._user_point = None
 
+        # Parameters for the load function
+        self._load_params = {**self._sample.load_params, **kwargs}
+        self._load_params['redshift'] = 0
+
         # Output Log params
         self._log_address = output_file_log
 
@@ -904,9 +929,6 @@ class RedshiftInspection:
             # Plot on screen unless an output address is provided
             save_close_fig_swicth(output_address, 'tight', self._fig, maximise=maximize)
 
-        # else:
-        #     _logger.warning(f'The sample does not have objects. The redshift check could not be done')
-
         return
 
     def _launch_plots_ZI(self):
@@ -944,8 +966,7 @@ class RedshiftInspection:
         for i, obj_idx in enumerate(self._obj_idcs):
 
             # Load the spectrum with a zero redshift
-            load_params = {**self._sample.load_params, **{'redshift': 0}}
-            spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **load_params)
+            spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **self._load_params)
 
             # Plot on the observed frame with reshift = 0
             wave_plot, flux_plot, z_corr, idcs_mask = frame_mask_switch(spec.wave, spec.flux, spec.redshift, 'observed')
@@ -966,8 +987,7 @@ class RedshiftInspection:
             for obj_idx in self._obj_idcs:
 
                 # Load the spectrum
-                load_params = {**self._sample.load_params, **{'redshift': 0}}
-                spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **load_params)
+                spec = self._sample.load_function(self._sample.frame, obj_idx, self._sample.file_address, **self._load_params)
 
                 wavelength = spec.wave.data
                 wavelength = wavelength[~np.isnan(wavelength)]
@@ -1042,13 +1062,12 @@ class RedshiftInspection:
             _redshift_pred = redshift_output
 
         # Store the new redshift
-        #
+
         self._sample.loc[self._output_idcs, self._column_log] = _redshift_pred
 
         # Save to file if provided
         if self._log_address is not None:
             save_frame(self._log_address, self._sample.frame)
-
         return
 
     def _button_ZI(self, line_selection):

lime/plotting/theme_lime.toml

@@ -109,6 +109,7 @@ mask_marker = '#FF0000'
 inspection_positive = '#FFFFFF'
 inspection_negative = '#ff796c' # 'xkcd:salmon'
 fade_fg = "#FFE5B4"
+err_area = "#00FF00"
 
 [colors.dark] # Dark theme
 bg = "#2B2B2B"
@@ -128,4 +129,5 @@ comps_map = 'PuRd'
 mask_marker = '#FF0000'
 inspection_positive = "#2B2B2B"
 inspection_negative = '#840000'
-fade_fg = "#73879B"
+fade_fg = "#73879B"
+err_area = "#00FF00"

lime/transitions.py

@@ -749,6 +749,7 @@ class Line:
         self.kinem = None
         self.profile_comp = profile
         self.transition_comp = None
+        self.core = None
 
         self._ref_idx = None
         self._p_type = None
@@ -843,9 +844,11 @@ class Line:
         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
-        core_comp = f'{comps_list[0]}_{comps_list[1]}'
-        self.mask = label_mask_assigning(self.label, band, self.blended_check, self.merged_check, core_comp)
+        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')
@@ -1039,89 +1042,93 @@ class Line:
         else:
             return idcs_bands
 
-    def index_bands_orig(self, wavelength_array, redshift, merge_continua=True, just_band_edges=False):
-
-        if self.mask is None:
-            raise LiMe_Error(f'The line {self.label} does include bands. Please select another line or update the database.')
-
-        # Make sure it is a matrix
-        bands_arr = np.atleast_2d(self.mask) * (1 + redshift)
-
-        # if np.any(bands_arr[:, 0] < wavelength_array[0]) or np.any(bands_arr[:, 5] > wavelength_array[-1]):
-        #     _logger.warning(f'The {self.label} bands do not match the spectrum wavelength range (observed):')
-        #     _logger.warning(                f'-- The spectrum wavelength range is: ({wavelength_array[0]:0.2f}, {wavelength_array[-1]:0.2f}) (observed frame)')
-        #     _logger.warning(f'-- The {self.label} bands are: {bands_arr} (rest frame * (1 + z))')
-
-        # Check if it is a masked array
-        wave_arr = wavelength_array.data
-
-        # Remove masked pixels from this function wavelength array
-        if self.pixel_mask != 'no':
-
-            # Convert cfg mask string to limits
-            line_mask_limits = format_line_mask_option(self.pixel_mask, wave_arr)
-
-            # Get masked indeces
-            idcsMask = (wave_arr[:, None] >= line_mask_limits[:, 0]) & (wave_arr[:, None] <= line_mask_limits[:, 1])
-            idcsValid = ~idcsMask.sum(axis=1).astype(bool)[:, None]
-
-        else:
-            idcsValid = np.ones(wave_arr.size).astype(bool)[:, None]
-
-        # Find indeces for six points in spectrum
-        idcsW = np.searchsorted(wave_arr, bands_arr)
+    # def index_bands_orig(self, wavelength_array, redshift, merge_continua=True, just_band_edges=False):
+    #
+    #     if self.mask is None:
+    #         raise LiMe_Error(f'The line {self.label} does include bands. Please select another line or update the database.')
+    #
+    #     # Make sure it is a matrix
+    #     bands_arr = np.atleast_2d(self.mask) * (1 + redshift)
+    #
+    #     # if np.any(bands_arr[:, 0] < wavelength_array[0]) or np.any(bands_arr[:, 5] > wavelength_array[-1]):
+    #     #     _logger.warning(f'The {self.label} bands do not match the spectrum wavelength range (observed):')
+    #     #     _logger.warning(                f'-- The spectrum wavelength range is: ({wavelength_array[0]:0.2f}, {wavelength_array[-1]:0.2f}) (observed frame)')
+    #     #     _logger.warning(f'-- The {self.label} bands are: {bands_arr} (rest frame * (1 + z))')
+    #
+    #     # Check if it is a masked array
+    #     wave_arr = wavelength_array.data
+    #
+    #     # Remove masked pixels from this function wavelength array
+    #     if self.pixel_mask != 'no':
+    #
+    #         # Convert cfg mask string to limits
+    #         line_mask_limits = format_line_mask_option(self.pixel_mask, wave_arr)
+    #
+    #         # Get masked indeces
+    #         idcsMask = (wave_arr[:, None] >= line_mask_limits[:, 0]) & (wave_arr[:, None] <= line_mask_limits[:, 1])
+    #         idcsValid = ~idcsMask.sum(axis=1).astype(bool)[:, None]
+    #
+    #     else:
+    #         idcsValid = np.ones(wave_arr.size).astype(bool)[:, None]
+    #
+    #     # Find indeces for six points in spectrum
+    #     idcsW = np.searchsorted(wave_arr, bands_arr)
+    #
+    #     # Return just the edges of the bands
+    #     if just_band_edges:
+    #         outputs = idcsW[0]
+    #
+    #     # Return the indeces of all the pixels within the bands
+    #     else:
+    #
+    #         # Emission region
+    #         idcsLineRegion = ((wave_arr[idcsW[:, 2]] <= wave_arr[:, None]) & (
+    #                     wave_arr[:, None] <= wave_arr[idcsW[:, 3]]) & idcsValid).squeeze()
+    #
+    #         # Return left and right continua merged in one array
+    #         if merge_continua:
+    #             idcsContRegion = (((wave_arr[idcsW[:, 0]] <= wave_arr[:, None]) &
+    #                                (wave_arr[:, None] <= wave_arr[idcsW[:, 1]])) |
+    #                               ((wave_arr[idcsW[:, 4]] <= wave_arr[:, None]) & (
+    #                                       wave_arr[:, None] <= wave_arr[idcsW[:, 5]])) & idcsValid).squeeze()
+    #
+    #             outputs = idcsLineRegion, idcsContRegion
+    #
+    #         # Return left and right continua in separated arrays
+    #         else:
+    #             idcsContLeft = ((wave_arr[idcsW[:, 0]] <= wave_arr[:, None]) & (
+    #                         wave_arr[:, None] <= wave_arr[idcsW[:, 1]]) & idcsValid).squeeze()
+    #             idcsContRight = ((wave_arr[idcsW[:, 4]] <= wave_arr[:, None]) & (
+    #                         wave_arr[:, None] <= wave_arr[idcsW[:, 5]]) & idcsValid).squeeze()
+    #
+    #             outputs = idcsLineRegion, idcsContLeft, idcsContRight
+    #
+    #     return outputs
 
-        # Return just the edges of the bands
-        if just_band_edges:
-            outputs = idcsW[0]
+    def update_label(self, decimals=None, update_latex=True, bands_df=None, vacuum_label=False):
 
-        # Return the indeces of all the pixels within the bands
+        # Reference wavelength
+        if (vacuum_label is True) and (bands_df is not None):
+            wave_ref = pd_get(bands_df, self.label, 'wave_vac')
         else:
+            wave_ref = self.wavelength[self._ref_idx]
 
-            # Emission region
-            idcsLineRegion = ((wave_arr[idcsW[:, 2]] <= wave_arr[:, None]) & (
-                        wave_arr[:, None] <= wave_arr[idcsW[:, 3]]) & idcsValid).squeeze()
-
-            # Return left and right continua merged in one array
-            if merge_continua:
-                idcsContRegion = (((wave_arr[idcsW[:, 0]] <= wave_arr[:, None]) &
-                                   (wave_arr[:, None] <= wave_arr[idcsW[:, 1]])) |
-                                  ((wave_arr[idcsW[:, 4]] <= wave_arr[:, None]) & (
-                                          wave_arr[:, None] <= wave_arr[idcsW[:, 5]])) & idcsValid).squeeze()
-
-                outputs = idcsLineRegion, idcsContRegion
-
-            # Return left and right continua in separated arrays
-            else:
-                idcsContLeft = ((wave_arr[idcsW[:, 0]] <= wave_arr[:, None]) & (
-                            wave_arr[:, None] <= wave_arr[idcsW[:, 1]]) & idcsValid).squeeze()
-                idcsContRight = ((wave_arr[idcsW[:, 4]] <= wave_arr[:, None]) & (
-                            wave_arr[:, None] <= wave_arr[idcsW[:, 5]]) & idcsValid).squeeze()
-
-                outputs = idcsLineRegion, idcsContLeft, idcsContRight
-
-        return outputs
-
-    def update_label(self, decimals=None, update_latex=True, bands_df=None):
-
-        # Convert core transition particle
+        # Core transition particle
         part_str = self.particle[self._ref_idx]
-        wave_str = np.round(self.wavelength[self._ref_idx], 0).astype(int) if decimals is None else np.round(self.wavelength[self._ref_idx], decimals)
+        wave_str = np.round(wave_ref, 0).astype(int) if decimals is None else np.round(wave_ref, decimals)
         units_str = f'{self.units_wave[self._ref_idx]}' if self.units_wave[self._ref_idx] != 'Angstrom' else 'A'
         module_str = "_b" if self.blended_check else "_m" if self.merged_check else ""
+
+        # Optional components
         kinem_str = f'_k-{self.kinem[self._ref_idx]}' if self.kinem[self._ref_idx] != 0 else ''
         profile_str = f'_p-{self.profile_comp[self._ref_idx]}' if self.profile_comp[self._ref_idx] != 'g-emi' else ''
         trans_str = f'_t-{self.kinem[self._ref_idx]}' if not self.profile_comp[self._ref_idx] not in ['rec', 'col'] else ''
 
-        # New label
+        # Set label
         self.label = f'{part_str}_{wave_str}{units_str}{module_str}{kinem_str}{profile_str}{trans_str}'
 
         # Update latex notation
         if update_latex:
             self.latex_label = self._review_science_notation(bands_df, update_latex, decimals=decimals)
 
-        return
-
-    def get_latex_label(self):
-
         return