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

lime/__init__.py

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

lime/archives/read_fits.py

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

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

lime/fitting/lines.py

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

lime/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/inference/intensity_threshold.py

@@ -52,8 +52,8 @@ class LineFinder:
 
         return
 
-    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5, band_modification=None,
-                       continuum_array=None, continuum_std=None, plot_steps=False, log_scale=False):
+    def peaks_troughs(self, bands, sigma_threshold=3, emission_type=True, width_tol=5,
+                       continuum_array=None, continuum_std=None, plot_steps=False, **kwargs):
 
         """
 
@@ -82,9 +82,6 @@ class LineFinder:
         :param width_tol: Minimum number of pixels between peaks/troughs. The default value is 5.
         :type width_tol: float, optional
 
-        :param band_modification: Method to adjust the line band with. The default value is None.
-        :type band_modification: str, optional
-
         :param ml_detection: Machine learning algorithm to detect lines. The default value is None.
         :type ml_detection: str, optional
 
@@ -105,101 +102,36 @@ class LineFinder:
 
         # Match peaks with theoretical lines
         bands = check_file_dataframe(bands)
-        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, band_modification=band_modification,
-                                      line_type=emission_type)
+        matched_DF = self.label_peaks(idcs_peaks, bands, width_tol=width_tol, line_type=emission_type)
 
         # Plot the results
         if plot_steps:
-            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, log_scale)
+            plot_peaks_troughs(self._spec, idcs_peaks, limit_threshold, continuum_array, matched_DF, **kwargs)
 
         return matched_DF
 
 
-    def label_peaks(self, peak_table, mask_df, line_type='emission', width_tol=5, band_modification=None, detect_check=False):
-
-        # TODO auto param should be changed to boolean
-        # Establish the type of input values for the peak indexes, first numpy array
-        if isinstance(peak_table, np.ndarray):
-            idcsLinePeak = peak_table
-
-        # Specutils table
-        else:
-            # Query the lines from the astropy finder archives #
-            if len(peak_table) != 0:
-                idcsLineType = peak_table['emission_type'] == line_type
-                idcsLinePeak = np.array(peak_table[idcsLineType]['line_center_index'])
-            else:
-                idcsLinePeak = np.array([])
+    def label_peaks(self, idcs_peaks, matched_DF, line_type='emission', width_tol=5):
 
         # Security check in case no lines detected
-        if len(idcsLinePeak) == 0:
-            return pd.DataFrame(columns=mask_df.columns)
-
-        # Exclude bands not withing the regime:
-        w0, wf = self._spec.wave_rest.data[~self._spec.wave_rest.mask][0],  self._spec.wave_rest.data[~self._spec.wave_rest.mask][-1]
-        idcs_selection = (mask_df.w3 > w0) & (mask_df.w4 < wf)
-
-        # Prepare dataframe to stored the matched lines
-        matched_DF = mask_df.loc[idcs_selection].copy()
-        matched_DF['signal_peak'] = np.nan
-
-        # Theoretical wave values
-        waveTheory = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
-        matched_DF['wavelength'] = waveTheory
-
-        # Match the lines with the theoretical emission
-        tolerance = np.diff(self._spec.wave_rest).mean() * width_tol
-        matched_DF['observation'] = 'not_detected'
-        unidentifiedLine = dict.fromkeys(matched_DF.columns.values, np.nan)
-
-        # Get the wavelength peaks
-        wave_peaks = self._spec.wave_rest[idcsLinePeak]
-
-        for i in np.arange(wave_peaks.size):
-
-            idx_array = np.where(np.isclose(a=waveTheory.astype(np.float64), b=wave_peaks[i], atol=tolerance))
-
-            if len(idx_array[0]) == 0:
-                unknownLineLabel = 'xy_{:.0f}A'.format(np.round(wave_peaks[i]))
-
-                # Scheme to avoid repeated lines
-                if (unknownLineLabel not in matched_DF.index) and detect_check:
-                    newRow = unidentifiedLine.copy()
-                    newRow.update({'wavelength': wave_peaks[i], 'w3': wave_peaks[i] - 5, 'w4': wave_peaks[i] + 5,
-                                   'observation': 'not_identified'})
-                    matched_DF.loc[unknownLineLabel] = newRow
-
-            else:
-
-                row_index = matched_DF.index[matched_DF.wavelength == waveTheory[idx_array[0][0]]]
-                matched_DF.loc[row_index, 'observation'] = 'detected'
-                matched_DF.loc[row_index, 'signal_peak'] = idcsLinePeak[i]
-                theoLineLabel = row_index[0]
-
-                blended_check = True if '_b' in theoLineLabel else False
-                minSeparation = 4 if blended_check else 2
+        if len(idcs_peaks) == 0:
+            return pd.DataFrame(columns=matched_DF.columns)
 
-                # Width is only computed for blended lines
-                if band_modification is not None:
-                    if band_modification == 'auto':
-                        if blended_check is False:
-                            emission_check = True if line_type == 'emission' else False
-                            idx_min = compute_line_width(idcsLinePeak[i], self._spec.flux, delta_i=-1, min_delta=minSeparation, emission_check=emission_check)
-                            idx_max = compute_line_width(idcsLinePeak[i], self._spec.flux, delta_i=1, min_delta=minSeparation, emission_check=emission_check)
-                            matched_DF.loc[row_index, 'w3'] = self._spec.wave_rest[idx_min]
-                            matched_DF.loc[row_index, 'w4'] = self._spec.wave_rest[idx_max]
+        # Add theoretical wavelength values if necessary
+        if 'wavelength' not in matched_DF.columns:
+            matched_DF['wavelength'] = label_decomposition(matched_DF.index.values, params_list=['wavelength'])[0]
 
-        # Include_only_detected
-        idcs_unknown = matched_DF['observation'] == 'not_detected'
-        matched_DF.drop(index=matched_DF.loc[idcs_unknown].index.values, inplace=True)
+        # Get bands limits indexes
+        idcs_w3 = np.searchsorted(self._spec.wave_rest, matched_DF.w3)
+        idcs_w4 = np.searchsorted(self._spec.wave_rest, matched_DF.w4)
 
-        # Sort by wavelength
-        matched_DF.sort_values('wavelength', inplace=True)
-        matched_DF.drop(columns=['wavelength', 'observation'], inplace=True)
+        # Get the bands matching
+        band_contains_peak = (idcs_peaks[None, :] > idcs_w3[:, None]) & (idcs_peaks[None, :] < idcs_w4[:, None])
+        idcs_matched_bands = band_contains_peak.any(axis=1)
+        idcs_matched_peaks = idcs_peaks[band_contains_peak.argmax(axis=1)[idcs_matched_bands]]
 
-        # Security check all bands are within selection
-        wave_peak_matched = self._spec.wave_rest[matched_DF.signal_peak.to_numpy().astype(int)]
-        idcs_valid = (matched_DF.w3 < wave_peak_matched) & (matched_DF.w4 > wave_peak_matched)
-        matched_DF = matched_DF.loc[idcs_valid]
+        # Crop the bands to the detection
+        matched_DF.loc[idcs_matched_bands, 'observation'] = 'detected'
+        matched_DF.loc[idcs_matched_bands, 'signal_peak'] = idcs_matched_peaks
 
-        return matched_DF
+        return matched_DF.loc[idcs_matched_bands]

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.dev6"

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

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

lime/plotting/format.py

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