lime-stable 2.0.5__tar.gz → 2.2.dev2__tar.gz

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/MANIFEST.in

@@ -3,4 +3,4 @@ include src/lime/changelog.txt
 include src/lime/plotting/theme_lime.toml
 include src/lime/resources/parent_mask.txt
 include src/lime/resources/types_params.txt
-include src/lime/resources/lines_database_v2.0.0.txt
+include src/lime/resources/lines_database_v2.0.6.txt

{lime_stable-2.0.5/src/lime_stable.egg-info → lime_stable-2.2.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lime-stable
-Version: 2.0.5
+Version: 2.2.dev2
 Summary: Line measuring algorithm for astronomical spectra
 Author-email: Vital Fernández <vgf@stsci.edu>
 License: GPL-3.0-or-later
@@ -18,7 +18,7 @@ Requires-Dist: scipy~=1.16
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: full
 Requires-Dist: asdf~=4.1; extra == "full"
-Requires-Dist: aspect-stable~=0.5.1; extra == "full"
+Requires-Dist: aspect-stable~=0.7.dev1; extra == "full"
 Requires-Dist: bokeh~=3.8; extra == "full"
 Requires-Dist: mplcursors~=0.6; extra == "full"
 Requires-Dist: openpyxl~=3.1; extra == "full"

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lime-stable"
-version = "2.0.5"
+version = "2.2.dev2"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 license = {text = "GPL-3.0-or-later"}
@@ -24,7 +24,7 @@ dependencies = ["astropy~=7.1",
 
 [project.optional-dependencies]
 full = ["asdf~=4.1",
-        "aspect-stable~=0.5.1",
+        "aspect-stable~=0.7.dev1",
         "bokeh~=3.8",
         "mplcursors~=0.6",
         "openpyxl~=3.1",

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/src/lime/archives/read_fits.py

@@ -265,6 +265,7 @@ def check_fits_instructions(fits_source, online_provider=False):
             fits_reader = getattr(fits_manager, fits_source)
         else:
             source_type = 'instrument' if online_provider is False else 'survey'
+            # TODO show instruments supported
             raise LiMe_Error(f'Input {source_type} "{fits_source}" is not recognized. LiMe observation cannot be created.')
 
     else:
@@ -375,6 +376,40 @@ def load_fits(fits_address, data_ext_list=None, hdr_ext_list=None, url_check=Fal
     return data_list, header_list
 
 
+def join_spectra_matrix(wave, flux, err=None):
+
+    # Make sure the wavelength array is increasing
+    # for i in range(wave.shape[0]):
+    #     if wave[i, 0] > wave[i, -1]:
+    #         wave[i] = wave[i, ::-1]
+    #         flux[i] = flux[i, ::-1]
+    #         err[i] = err[i, ::-1] if err is not None else None
+
+    # Make sure the passes are sorted:
+    key = np.nanmean(wave, axis=1)
+    order = np.argsort(key)
+    wave, flux, err = wave[order], flux[order], err[order] if err is not None else None
+
+    # Get dimensions
+    n_passes, n_pix = wave.shape
+
+    join_wl = 0.5 * (wave[:-1, -1] + wave[1:, 0])
+    cut_idx = np.sum(wave[:-1] <= join_wl[:, None], axis=1)
+    cut_idx = np.append(cut_idx, n_pix)
+
+    pix = np.arange(n_pix)
+    mask = pix < cut_idx[:, None]
+
+    wave_1d = wave[mask]
+    flux_1d = flux[mask]
+    err_1d = err[mask] if err is not None else None
+
+    lengths = np.sum(mask, axis=1)
+    starts = np.concatenate(([0], np.cumsum(lengths[:-1])))
+
+    return wave_1d, flux_1d, err_1d
+
+
 class OpenFits:
 
     def __init__(self, file_address, file_source=None, load_function=None, lime_object=None):
@@ -785,30 +820,42 @@ class OpenFits:
 
         """
 
-        # Check dimensions of array
+        # Read the array
         data_list, header_list = load_fits(fits_address, data_ext_list, hdr_ext_list, url_check=False)
+
+        # Warning in the case of empty observartion
+        if len(data_list[0]['WAVELENGTH'].squeeze()) == 0:
+            _logger.critical(f'Input COS observation does not have scientific data ({fits_address}).')
+
+        # One single array with the data
         if data_list[0]['WAVELENGTH'].squeeze().ndim == 1:
             wave_arr = data_list[0]['WAVELENGTH'].squeeze()
             flux_arr = data_list[0]['FLUX'].squeeze()
             err_arr = data_list[0]['ERROR'].squeeze()
 
+        # Multiple passes
         else:
-            # Get common middle index for joining the spectra
-            # wave_matrix = data_list[0]['WAVELENGTH'][::-1]
-            idcs_common = np.nonzero(data_list[0]['WAVELENGTH'][1, :] > data_list[0]['WAVELENGTH'][0, 0])[0]
-            center_idx = idcs_common.shape[0] // 2
-
-            # Create empty containers
-            wave_arr = np.empty(data_list[0]['WAVELENGTH'].size - center_idx, data_list[0]['WAVELENGTH'].dtype)  # TODO check for additional extension to join the spectra
-            flux_arr = np.empty(data_list[0]['FLUX'].size - center_idx, data_list[0]['FLUX'].dtype)  # dtype=data_list[0]['FLUX'].dtype)
-            err_arr = np.empty(data_list[0]['ERROR'].size - center_idx, data_list[0]['ERROR'].dtype)  # dtype=data_list[0]['ERROR'].dtype)
-
-            # Fill with the array data
-            arr_size = data_list[0]['WAVELENGTH'].shape[1]
-            for key_arr, cont_arr in zip(['WAVELENGTH', 'FLUX', 'ERROR'], [wave_arr, flux_arr, err_arr]):
-                cont_arr[0:arr_size - center_idx] = data_list[0][key_arr][1][0:arr_size - center_idx]
-                cont_arr[arr_size - center_idx:] = data_list[0][key_arr][0]
-                # print(key_arr, np.any(np.isnan(cont_arr)))
+
+            wave_arr, flux_arr, err_arr = join_spectra_matrix(data_list[0]['WAVELENGTH'],
+                                                              data_list[0]['FLUX'],
+                                                              data_list[0]['ERROR'])
+
+            # # Get common middle index for joining the spectra
+            # # wave_matrix = data_list[0]['WAVELENGTH'][::-1]
+            # idcs_common = np.nonzero(data_list[0]['WAVELENGTH'][1, :] > data_list[0]['WAVELENGTH'][0, 0])[0]
+            # center_idx = idcs_common.shape[0] // 2
+            #
+            # # Create empty containers
+            # wave_arr = np.empty(data_list[0]['WAVELENGTH'].size - center_idx, data_list[0]['WAVELENGTH'].dtype)  # TODO check for additional extension to join the spectra
+            # flux_arr = np.empty(data_list[0]['FLUX'].size - center_idx, data_list[0]['FLUX'].dtype)  # dtype=data_list[0]['FLUX'].dtype)
+            # err_arr = np.empty(data_list[0]['ERROR'].size - center_idx, data_list[0]['ERROR'].dtype)  # dtype=data_list[0]['ERROR'].dtype)
+            #
+            # # Fill with the array data
+            # arr_size = data_list[0]['WAVELENGTH'].shape[1]
+            # for key_arr, cont_arr in zip(['WAVELENGTH', 'FLUX', 'ERROR'], [wave_arr, flux_arr, err_arr]):
+            #     cont_arr[0:arr_size - center_idx] = data_list[0][key_arr][1][0:arr_size - center_idx]
+            #     cont_arr[arr_size - center_idx:] = data_list[0][key_arr][0]
+            #     # print(key_arr, np.any(np.isnan(cont_arr)))
 
         # Spectrum properties
         params_dict = SPECTRUM_FITS_PARAMS['cos']

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/src/lime/fitting/redshift.py

@@ -149,9 +149,6 @@ def redshift_key_method(spec, bands, z_min, z_max, delta_z, pred_arr, components
         if spec.res_power is not None:
             res_power = spec.res_power
         else:
-            # wave_arr / np.r_[np.diff(wave_arr), np.diff(wave_arr)[-1]]
-            # alpha_lambda = np.diff(wave_arr)
-            # res_power = wave_arr / np.r_[alpha_lambda, alpha_lambda[-1]]
             delta_lambda = np.ediff1d(wave_arr, to_end=0)
             delta_lambda[-1] = delta_lambda[-2]
             res_power = wave_arr / delta_lambda
@@ -166,8 +163,6 @@ def redshift_key_method(spec, bands, z_min, z_max, delta_z, pred_arr, components
         z_arr = np.arange(z_min, z_max + 0.5 * delta_z, delta_z)
 
         # Parameters for the brute analysis
-        # z_arr = np.linspace(z_min, z_max, z_nsteps)
-        # z_arr = np.arange(z_min, z_max, step=0.005)
         wave_matrix = np.tile(wave_arr, (theo_lambda.size, 1))
         flux_sum = np.zeros(z_arr.size)
 
@@ -197,7 +192,7 @@ def redshift_key_method(spec, bands, z_min, z_max, delta_z, pred_arr, components
 
     if plot_results and (z_infer is not None):
         gauss_arr_max = compute_gaussian_ridges(z_infer, theo_lambda, wave_matrix, 1, band_vsigma, res_power)
-        redshift_key_evaluation(spec, method, z_infer, mask, gauss_arr_max, z_arr, flux_sum)
+        redshift_key_evaluation(spec, method, z_infer, mask, gauss_arr_max, z_arr, flux_sum, theo_lambda)
 
     return z_infer
 

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/src/lime/io.py

@@ -141,7 +141,6 @@ def parse_lime_cfg(toml_cfg, fit_cfg_suffix='_line_fitting'):
     return toml_cfg
 
 
-# Function to load configuration file
 def load_cfg(file_address, fit_cfg_suffix='_line_fitting'):
 
     """
@@ -206,7 +205,6 @@ def load_cfg(file_address, fit_cfg_suffix='_line_fitting'):
     return cfg_lime
 
 
-# Function to save SpecSyzer configuration file
 def save_cfg(output_file, param_dict, section_name=None, clear_section=False):
 
     """
@@ -221,9 +219,32 @@ def save_cfg(output_file, param_dict, section_name=None, clear_section=False):
 
         # TODO review convert numpy arrays and floats64
         if toml_check:
-            toml_dict = param_dict if section_name is None else {section_name: param_dict}
-            with open(output_file, "w") as f:
-                toml.dump(toml_dict, f)
+
+            # Section dict or the default dictionary
+            output_data = param_dict if section_name is None else {section_name: param_dict}
+
+            # If the file does not exist create a new file
+            if not output_path.is_file():
+                with open(output_file, "w") as f:
+                    toml.dump(output_data, f)
+
+            # Load the file and add the new section
+            else:
+                with open(output_path, 'r') as f:
+                    full_config = toml.load(f)
+
+                # Update the section data
+                full_config.update(output_data)
+                # if section_name is not None:
+                #     full_config.update(output_data)
+                #
+                # # Add the new data
+                # else:
+                #     full_config.update(output_data)
+
+                # Save the new data
+                with open(output_file, "w") as f:
+                    toml.dump(full_config, f)
 
         else:
             raise LiMe_Error(f'toml library is not installed. Toml files cannot be saved')
@@ -538,7 +559,7 @@ def save_frame(fname, dataframe, page='FRAME', parameters='all', header=None, co
 
                 lineLogHDU = log_to_HDU(lines_log, ext_name=page, column_dtypes=column_dtypes, header_dict=header)
 
-                if log_path.is_file(): # TODO this strategy is slow for many 2_guides
+                if log_path.is_file(): # TODO this strategy is slow for many configuration
                     try:
                         fits.update(log_path, data=lineLogHDU.data, header=lineLogHDU.header, extname=lineLogHDU.name, verify=True)
                     except KeyError:

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/src/lime/lime.toml

@@ -1,6 +1,6 @@
 [metadata]
 name = 'lime-stable'
-version = "2.0.5"
+version = "2.2.dev2"
 
 # =====================
 # Spectrum / Long-slit

{lime_stable-2.0.5 → lime_stable-2.2.dev2}/src/lime/observations.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from astropy.io import fits
 from collections import UserDict
 
+from lime.fitting.lines import profiles_computation, linear_continuum_computation
 from lime.tools import extract_fluxes, normalize_fluxes, ProgressBar, check_units, extract_wcs_header, \
     parse_unit_convertion
 
@@ -157,6 +158,7 @@ def check_spectra_arrays(observation):
 
     return
 
+
 def check_redshift_norm(redshift, norm_flux, flux_array, units_flux, norm_factor=1, min_flux_scale=0.001, max_flux_scale=1e50):
 
     if (redshift is None) or np.isnan(redshift) or np.isinf(redshift):
@@ -226,10 +228,10 @@ def check_sample_levels(levels, necessary_levels=("id", "file")):
     return
 
 
-def cropping_spectrum(crop_waves, input_wave, input_flux, input_err, pixel_mask):
+def cropping_spectrum(crop_waves, crop_flux, input_wave, input_flux, input_err, pixel_mask):
 
     if crop_waves is not None:
-
+        # TODO warning message
         idx_min = np.searchsorted(input_wave, crop_waves[0]) if crop_waves[0] != 0 else 0
         idx_max = np.searchsorted(input_wave, crop_waves[1]) if crop_waves[1] != -1 else None
 
@@ -256,6 +258,23 @@ def cropping_spectrum(crop_waves, input_wave, input_flux, input_err, pixel_mask)
         if pixel_mask is not None:
             pixel_mask = pixel_mask[idcs_crop[0]:idcs_crop[1]]
 
+    if crop_flux is not None:
+
+        # Validate percentiles
+        for perctl, name in zip(crop_flux, ("Min percentile", "Max percentile")):
+            if not np.isscalar(perctl):
+                raise TypeError(f"{name} must be a scalar.")
+            if not (0.0 <= perctl <= 100):
+                raise ValueError(f"{name} must be in the range [0, 100].")
+
+        if crop_flux[0] >= crop_flux[1]:
+            raise ValueError(f"The lower percentile limit ({crop_flux[0]}) must be  must be smaller than upper limit "
+                             f"({crop_flux[1]}).")
+
+        # Clip the flux to the limits
+        lo, hi = np.percentile(input_flux[~pixel_mask], crop_flux)
+        input_flux[~pixel_mask] = np.clip(input_flux[~pixel_mask], lo, hi)
+
     return input_wave, input_flux, input_err, pixel_mask
 
 
@@ -416,7 +435,8 @@ class Spectrum:
     _fitsMgr = None
 
     def __init__(self, input_wave=None, input_flux=None, input_err=None, redshift=None, norm_flux=None, crop_waves=None,
-                 res_power=None, units_wave='AA', units_flux='FLAM', pixel_mask=None, id_label=None, review_inputs=True):
+                 crop_flux=None, res_power=None, units_wave='AA', units_flux='FLAM', pixel_mask=None, id_label=None,
+                 review_inputs=True):
 
         # Class attributes
         self.label = None
@@ -447,7 +467,7 @@ class Spectrum:
 
         # Review and assign the attibutes data
         if review_inputs:
-            self._set_attributes(input_wave, input_flux, input_err, redshift, norm_flux, crop_waves, res_power,
+            self._set_attributes(input_wave, input_flux, input_err, redshift, norm_flux, crop_waves, crop_flux, res_power,
                                  units_wave, units_flux, pixel_mask, id_label)
 
         return
@@ -503,11 +523,6 @@ class Spectrum:
         # Class attributes
         spec.label = label
         spec.flux = cube.flux[:, idx_j, idx_i]
-        # from matplotlib import pyplot as plt
-        # fig, ax = plt.subplots()
-        # ax.imshow(cube.err_flux[500, :, :].data)
-        # plt.show()
-
         spec.err_flux = None if cube.err_flux is None else cube.err_flux[:, idx_j, idx_i]
         spec.norm_flux = cube.norm_flux
         spec.redshift = cube.redshift
@@ -526,7 +541,7 @@ class Spectrum:
         return spec
 
     @classmethod
-    def from_file(cls, fname, instrument, redshift=None, norm_flux=None, crop_waves=None, res_power=None,
+    def from_file(cls, fname, instrument, redshift=None, norm_flux=None, crop_waves=None, crop_flux=None, res_power=None,
                   units_wave=None, units_flux=None, pixel_mask=None, id_label=None, wcs=None, **kwargs):
 
         """
@@ -623,8 +638,8 @@ class Spectrum:
         fits_args = cls._fitsMgr.parse_data_from_file(cls._fitsMgr.file_address, pixel_mask, **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)
+        input_args = dict(redshift=redshift, norm_flux=norm_flux, crop_waves=crop_waves, crop_flux=crop_flux,
+                          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')
@@ -675,8 +690,8 @@ class Spectrum:
         # Create the LiMe object
         return cls(**fits_args)
 
-    def _set_attributes(self, input_wave, input_flux, input_err, redshift, norm_flux, crop_waves, res_power, units_wave,
-                        units_flux, pixel_mask, label):
+    def _set_attributes(self, input_wave, input_flux, input_err, redshift, norm_flux, crop_waves, crop_flux, res_power,
+                        units_wave, units_flux, pixel_mask, label):
 
         # Class attributes
         self.label = label
@@ -691,8 +706,8 @@ class Spectrum:
         self.redshift, self.norm_flux = check_redshift_norm(redshift, norm_flux, input_flux, self.units_flux)
 
         # Crop the input spectrum if necessary
-        input_wave, input_flux, input_err, pixel_mask = cropping_spectrum(crop_waves, input_wave, input_flux, input_err,
-                                                                          pixel_mask)
+        input_wave, input_flux, input_err, pixel_mask = cropping_spectrum(crop_waves, crop_flux, input_wave, input_flux,
+                                                                          input_err, pixel_mask)
 
         # Normalization and masking
         self.wave, self.wave_rest, self.flux, self.err_flux = spec_normalization_masking(input_wave, input_flux,
@@ -925,6 +940,116 @@ class Spectrum:
 
         return
 
+    def save_spectrum(self, fname=None, line_label=None, ref_frame=None, split_components=False, **kwargs):
+
+        # Headers for the default list
+        headers = np.array(["wave", "flux", "err_flux", "pixel_mask"])
+
+        # Use the observation frame if none is provided
+        frame = self.frame if ref_frame is None else ref_frame
+
+        # By default report complete spectrum
+        idcs = (0, None)
+
+        # If a line is provided get indexes for the bands limits
+        line_measured = False
+        if line_label is not None:
+            if frame is not None:
+                if line_label in frame.index:
+                    bands_limits = frame.loc[line_label, 'w1':'w6']
+                    idcs_bands = np.searchsorted(self._spec.wave.data, bands_limits * (1 + self._spec.redshift))
+                    idcs = (idcs_bands[0], idcs_bands[5])
+                    line_measured = True
+                else:
+                    _logger.warning(f'Line {line_label} not found on observation frame')
+            else:
+                _logger.warning(f'No lines measured on object')
+
+        # Compute the bands
+        if line_measured:
+
+            # Declare line object and the components and its components from the frame
+            line = Line.from_transition(line_label, data_frame=frame)
+            line_list = line.list_comps
+
+            # Compute the linear components
+            gaussian_arr = profiles_computation(line_list, frame, 1 + self._spec.redshift, line.profile,
+                                                x_array=self._spec.wave.data[idcs[0]: idcs[1]])
+            linear_arr = linear_continuum_computation(line_list, frame, 1 + self._spec.redshift, x_array=self._spec.wave.data[idcs[0]: idcs[1]])
+
+            # Determine which component you want to extract:
+            if split_components is False:
+                gaussian_arr = gaussian_arr.sum(axis=1) + linear_arr[:, 0]
+                gaussian_arr = gaussian_arr.reshape(-1, 1)
+                line_hdrs = [line_label]
+            else:
+                gaussian_arr = gaussian_arr + linear_arr[:, 0][:, np.newaxis]
+                line_hdrs = line_list
+
+            # Add the line list to the headers
+            headers = np.append(headers, line_hdrs)
+
+        # Container for the data
+        out_arr = np.full((self.wave.data[idcs[0]: idcs[1]].size, len(headers)), np.nan)
+
+        # Fill the array:
+        out_arr[:, 0] = self.wave.data[idcs[0]: idcs[1]]
+        out_arr[:, 1] = self.flux.data[idcs[0]: idcs[1]] * self.norm_flux
+
+        # Err array if it exists
+        if self.err_flux is not None:
+            out_arr[:, 2] = self.err_flux[idcs[0]: idcs[1]].data * self.norm_flux
+
+        # Pixel mask if any is invalid
+        if np.any(self.wave.mask):
+            out_arr[:, 3] = self.wave[idcs[0]: idcs[1]].mask
+
+        # Add the components
+        if line_measured:
+            for i, line_comp in enumerate(line_hdrs):
+                out_arr[:, 4 + i] = gaussian_arr[:, i]
+
+        # Crop array if some columns are missing
+        nan_columns = np.zeros(out_arr.shape[1]).astype(bool)
+        nan_columns[:4] = np.all(np.isnan(out_arr[:, :4]), axis=0)
+        out_arr = out_arr[:, ~nan_columns]
+
+        # Headers
+        headers = headers[~nan_columns]
+
+        # Formatting for the data
+        spec_hdrs_list = ['%.18e', '%.18e', '%.18e', '%d']
+        spec_hdrs_list = spec_hdrs_list + ['%.18e'] * len(line_hdrs) if line_measured else spec_hdrs_list
+        array_fmt = np.array(spec_hdrs_list)
+        array_fmt = list(array_fmt[~nan_columns])
+
+        # Update defaults with user-provided values
+        default_kwargs = {"fmt": array_fmt, "delimiter": ' '}
+        default_kwargs.update(kwargs)
+
+        # Create header
+        if default_kwargs.get('header') is None:
+            default_kwargs['header'] = default_kwargs['delimiter'].join(headers)
+
+        # Dictionary with parameters
+        if 'footer' not in default_kwargs:
+            footer_dict = {'LiMe': f"v{lime_cfg['metadata']['version']}",
+                            'units_wave': self.units_wave, 'units_flux':  self.units_flux,
+                            'redshift': self.redshift, 'norm_flux': self.norm_flux, 'id_label': self.label}
+            footer_str = "\n".join(f"{key}:{value}" for key, value in footer_dict.items())
+            default_kwargs['footer'] = footer_str
+
+        # Return a recarray with the spectrum data
+        if fname is None:
+            output = np.core.records.fromarrays([out_arr[:, i] for i in range(out_arr.shape[1])], names=list(headers))
+
+        # Save to a file
+        else:
+            np.savetxt(fname, out_arr, **default_kwargs)
+            output = None
+
+        return output
+
     def update_redshift(self, redshift):
 
         """
@@ -982,20 +1107,23 @@ class Spectrum:
 
         return
 
-    def line_detection(self, *args, **kwargs):
-
-        raise LiMe_Error(f'The line_detection functionality has been moved an rebranded. Please use:\n'
-                         f'Spectrum.infer.peaks_troughs()')
-    
-    def clear_data(self):
+    def clear_data(self, line_data=True, cont_data=True):
 
         """
-        Clear the spectrum’s measurements frame.
+        Clear the spectrum’s line measurements frame and fitted continuum.
 
         This method removes all entries from the internal ``frame`` attribute,
         effectively resetting the stored measurements while preserving the
         dataframe structure (columns and metadata).
 
+        Parameters
+        ----------
+        line_data : bool, optional
+            Clear the spectrum’s line measurements frame. The default value is true.
+
+        cont_data : bool, optional
+            Clear the spectrum’s fitted continuum. The default value is true.
+
         Returns
         -------
         None
@@ -1005,6 +1133,7 @@ class Spectrum:
         -----
         - The operation is equivalent to reassigning ``self.frame = self.frame[0:0]``,
           which clears all rows but keeps column definitions intact.
+        - The Spectrum.cont and cont_std variables are set to None.
         - Use this method to reset the spectrum’s measurement results before
           reprocessing or refitting without recreating the object.
 
@@ -1017,7 +1146,12 @@ class Spectrum:
         (0, 10)
         """
 
-        self.frame = self.frame[0:0]
+        if line_data:
+            self.frame = self.frame[0:0]
+
+        if cont_data:
+            self.cont = None
+            self.cont_std = None
 
         return
 
@@ -1105,9 +1239,10 @@ class Cube:
     _fitsMgr = None
 
     def __init__(self, input_wave=None, input_flux=None, input_err=None, redshift=None, norm_flux=None, crop_waves=None,
-                 res_power=None, units_wave='AA', units_flux='FLAM', pixel_mask=None, id_label=None, wcs=None):
+                 crop_flux=None, res_power=None, units_wave='AA', units_flux='FLAM', pixel_mask=None, id_label=None,
+                 wcs=None):
 
-        # Review the 2_guides
+        # Review the inputs
         pixel_mask = check_inputs_arrays(input_wave, input_flux, input_err, pixel_mask, self)
 
         # Class attributes
@@ -1133,8 +1268,8 @@ class Cube:
         self.redshift, self.norm_flux = check_redshift_norm(redshift, norm_flux, input_flux, self.units_flux)
 
         # Start cropping the input spectrum if necessary
-        input_wave, input_flux, input_err, pixel_mask = cropping_spectrum(crop_waves, input_wave, input_flux, input_err,
-                                                                          pixel_mask)
+        input_wave, input_flux, input_err, pixel_mask = cropping_spectrum(crop_waves, crop_flux, input_wave, input_flux,
+                                                                          input_err, pixel_mask)
 
         # Spectrum normalization, redshift and mask calculation
         self.wave, self.wave_rest, self.flux, self.err_flux = spec_normalization_masking(input_wave, input_flux,
@@ -1336,7 +1471,7 @@ class Cube:
         >>> cube.spatial_masking("H1_4861A", param="SN_line", contour_pctls=[80, 90, 95])
         """
 
-        # Check the function 2_guides
+        # Check the function inputs
         contour_pctls = np.atleast_1d(contour_pctls)
         if not np.all(np.diff(contour_pctls) > 0):
             raise LiMe_Error(f'The mask percentiles ({contour_pctls}) must be in increasing order')
@@ -1561,7 +1696,7 @@ class Cube:
         --------
         Extract a single spaxel spectrum from a cube:
 
-        >>> spec = cube.spectrum_from_indices(25, 30)
+        >>> spec = cube.get_spectrum(25, 30)
 
         """