tests

Author: kbwestfall

specutils/io/default_loaders/tabular_fits.py

@@ -47,11 +47,11 @@ def tabular_fits_loader(file_obj, column_mapping=None, hdu=1, store_data_header=
 
     Parameters
     ----------
-    file_obj : str, file-like, or HDUList
-        FITS file name, object (provided from name by Astropy I/O Registry),
-        or HDUList (as resulting from astropy.io.fits.open()).
+    file_obj : str, file-like, or `~astropy.io.fits.HDUList`
+        FITS file name, object (provided from name by Astropy I/O Registry), or
+        `~astropy.io.fits.HDUList` (as resulting from `astropy.io.fits.open`).
     hdu : int
-        The HDU of the fits file (default: 1st extension) to read from
+        The HDU of the fits file (default: 1st extension) to read
     store_data_header : bool
         Defaults to ``False``, which stores the primary header in ``Spectrum.meta['header']``.
         Set to ``True`` to instead store the header from the specified data HDU.
@@ -86,11 +86,8 @@ def tabular_fits_loader(file_obj, column_mapping=None, hdu=1, store_data_header=
         else:
             tab.meta = hdulist[0].header
 
-        # Determine if there is a correlation matrix
-        correl = None
-        if 'CORREL' in [h.name for h in hdulist]:
-            correl = Table.read(hdulist['CORREL'])
-            correl.meta = hdulist['CORREL'].header
+        # Determine if there is a covariance matrix
+        covar = Table.read(hdulist['COVAR']) if 'COVAR' in [h.name for h in hdulist] else None
 
     # Minimal checks for wcs consistency with table data -
     # assume 1D spectral axis (having shape (0, NAXIS1),
@@ -102,9 +99,9 @@ def tabular_fits_loader(file_obj, column_mapping=None, hdu=1, store_data_header=
     # If no column mapping is given, attempt to parse the file using
     # unit information
     if column_mapping is None:
-        return generic_spectrum_from_table(tab, wcs=wcs, correl=correl, **kwargs)
+        return generic_spectrum_from_table(tab, wcs=wcs, covar=covar, **kwargs)
 
-    return spectrum_from_column_mapping(tab, column_mapping, wcs=wcs, correl=correl)
+    return spectrum_from_column_mapping(tab, column_mapping, wcs=wcs, covar=covar)
 
 
 @custom_writer("tabular-fits")
@@ -175,11 +172,11 @@ def tabular_fits_writer(spectrum, file_name, hdu=1, update_header=False, store_d
     colnames = [dispname, "flux"]
 
     # Include uncertainty - units to be inferred from spectrum.flux
-    correl = None
+    covar = None
     if spectrum.uncertainty is not None:
         if isinstance(spectrum.uncertainty, Covariance):
-            var, correl = spectrum.uncertainty.to_tables()
-            columns.append(np.sqrt(var) * funit)
+            covar = spectrum.uncertainty.to_table()
+            columns.append(np.sqrt(spectrum.uncertainty.variance) * funit)
             colnames.append("uncertainty")
         else:
             try:
@@ -224,8 +221,8 @@ def tabular_fits_writer(spectrum, file_name, hdu=1, update_header=False, store_d
         hdu1 = fits.BinTableHDU(data=tab, name='DATA')
 
     hdulist = fits.HDUList([hdu0, hdu1])
-    if correl is not None:
-        hdulist.append(fits.BinTableHDU(data=correl, name='CORREL'))
+    if covar is not None:
+        hdulist.append(fits.BinTableHDU(data=covar, name='COVAR'))
 
     # TODO: Use output_verify options to check for valid FITS
     hdulist.writeto(file_name, **kwargs)

specutils/io/parsing_utils.py

@@ -52,7 +52,7 @@ def read_fileobj_or_hdulist(*args, **kwargs):
                 hdulist.close()
 
 
-def spectrum_from_column_mapping(table, column_mapping, wcs=None, correl=None, verbose=False):
+def spectrum_from_column_mapping(table, column_mapping, wcs=None, covar=None, verbose=False):
     """
     Given a table and a mapping of the table column names to attributes
     on the Spectrum object, parse the information into a Spectrum.
@@ -76,10 +76,9 @@ def spectrum_from_column_mapping(table, column_mapping, wcs=None, correl=None, v
     wcs : :class:`~astropy.wcs.WCS` or :class:`gwcs.WCS`
         WCS object passed to the Spectrum initializer.
 
-    correl : `astropy.table.Table`, optional
-        Table with correlation matrix for the uncertainties in coordinate
-        format; see `~astropy.nddata.Covariance`. If None, uncertainties are
-        assumed to be uncorrelated.
+    covar : `astropy.table.Table`, optional
+        Table providing a covariance matrix for the uncertainties in coordinate
+        format; see `~astropy.nddata.Covariance`.
 
     verbose : bool
         Print extra info.
@@ -136,28 +135,27 @@ def spectrum_from_column_mapping(table, column_mapping, wcs=None, correl=None, v
         spec_kwargs.setdefault(kwarg_name, kwarg_val)
 
     # Ensure that the uncertainties are a subclass of NDUncertainty
-    if spec_kwargs.get('uncertainty') is None and correl is not None:
+    if spec_kwargs.get('uncertainty') is None and covar is not None:
         warnings.warn('Unable to parse uncertainty from provided table.  Ignoring provided '
-                      'correlation matrix data.')
-        correl = None
+                      'covariance matrix data.')
+        covar = None
     if spec_kwargs.get('uncertainty') is not None:
-        if correl is not None:
-            err = spec_kwargs.get('uncertainty')
+        if covar is not None:
             try:
-                spec_kwargs['uncertainty'] = Covariance.from_tables(err**2, correl)
+                spec_kwargs['uncertainty'] = Covariance.from_table(covar)
             except (ValueError, TypeError):
-                warnings.warn('Unable to parse correlation table into a Covariance object.  '
-                              'Ignoring correlation matrix data.')
-                correl = None
+                warnings.warn('Unable to parse table with covariance data into into a Covariance '
+                              'object.  Ignoring covariance matrix data.')
+                covar = None
         # NOTE: This is not an `else` or `elif` block in order to catch the
-        # change to correl=None when handling the exception above.
-        if correl is None:
+        # change to covar=None when handling the exception above.
+        if covar is None:
             spec_kwargs['uncertainty'] = StdDevUncertainty(spec_kwargs.get('uncertainty'))
 
     return Spectrum(**spec_kwargs, wcs=wcs, meta={'header': table.meta})
 
 
-def generic_spectrum_from_table(table, wcs=None, correl=None, **kwargs):
+def generic_spectrum_from_table(table, wcs=None, covar=None, **kwargs):
     """
     Load spectrum from an Astropy table into a Spectrum object.
     Uses the following logic to figure out which column is which:
@@ -174,15 +172,15 @@ def generic_spectrum_from_table(table, wcs=None, correl=None, **kwargs):
 
     Parameters
     ----------
-    table : `astropy.table.QTable`
-        Tabulated data with units
+    table : :class:`~astropy.table.Table`
+        Table containing a column of ``flux``, and optionally ``spectral_axis``
+        and ``uncertainty`` as defined above.
     wcs : :class:`~astropy.wcs.WCS`, optional
         A FITS WCS object. If this is present, the machinery will fall back
-        to using the wcs to find the dispersion information.
-    correl : `astropy.table.Table`, optional
-        Table with correlation matrix for the uncertainties in coordinate
-        format; see `~astropy.nddata.Covariance`. If None, uncertainties are
-        assumed to be uncorrelated.
+        to using the ``wcs`` to find the dispersion information.
+    covar : `astropy.table.Table`, optional
+        Table providing a covariance matrix for the uncertainties in coordinate
+        format; see `~astropy.nddata.Covariance`.
 
     Returns
     -------
@@ -297,24 +295,24 @@ def _find_spectral_column(table, columns_to_search, spectral_axis):
         if table[err_column].ndim > 1:
             err = table[err_column].T
         elif flux.ndim > 1:  # Repeat uncertainties over all flux columns
-            if correl is not None:
-                warnings.warn('When applying correlated errors, the dimensionality of the error '
+            if covar is not None:
+                warnings.warn('When applying covariance, the dimensionality of the error '
                               'array must match the dimensionality of the flux array.  Ignoring '
-                              'correlated errors.')
-                correl = None
+                              'covariance.')
+                covar = None
             err = np.tile(table[err_column], flux.shape[0], 1)
         else:
             err = table[err_column]
-        if correl is not None:
+        if covar is not None:
             try:
-                err = Covariance.from_tables(err**2, correl)
+                err = Covariance.from_table(covar)
             except (ValueError, TypeError):
-                warnings.warn('Unable to parse correlation table into a Covariance object.  '
-                              'Ignoring correlation matrix data.')
-                correl = None
+                warnings.warn('Unable to parse covariance table into a Covariance object.  '
+                              'Ignoring covariance matrix data.')
+                covar = None
         # NOTE: This is not an `else` or `elif` block in order to catch the
-        # change to correl=None when handling the exception above.
-        if correl is None:
+        # change to covar=None when handling the exception above.
+        if covar is None:
             err = StdDevUncertainty(err.to(err.unit))
             if np.min(table[err_column]) <= 0.:
                 warnings.warn("Standard Deviation has values of 0 or less", AstropyUserWarning)

specutils/spectra/spectrum.py

@@ -506,7 +506,7 @@ def __getitem__(self, item):
                 new_meta = deepcopy(self.meta)
 
             if isinstance(self.uncertainty, Covariance):
-                new_unc = self.uncertainty.sub_matrix(item)
+                new_unc = self.uncertainty.match_to_data_slice(item)
             elif self.uncertainty is not None:
                 new_unc = self.uncertainty[item]
             else:
@@ -933,7 +933,7 @@ def __str__(self):
         # Add information about uncertainties if available
         if self.uncertainty:
             _arr = (
-                self.uncertainty.toarray()
+                self.uncertainty.to_dense()
                 if isinstance(self.uncertainty, Covariance)
                 else self.uncertainty.array
             )

specutils/tests/test_loaders.py

@@ -610,25 +610,25 @@ def test_tabular_fits_cov_io(tmp_path):
         np.full(1000-1, 0.5, dtype=float),
         np.full(1000-2, 0.2, dtype=float),
     ]
-    cov = Covariance(array=sparse.diags(cov_diags, [0, 1, 2]), unit=u.Jy**2)
+    cov = Covariance(array=sparse.diags(cov_diags, [0, 1, 2]), unit=u.Jy**2, assume_symmetric=True)
 
     # Create the Spectrum1D
     spectrum = Spectrum1D(flux=flux, spectral_axis=wave, uncertainty=cov)
     # Simple test of ingestion
-    assert np.array_equal(spectrum.uncertainty.toarray(), cov.toarray()), \
+    assert np.array_equal(spectrum.uncertainty.to_dense(), cov.to_dense()), \
             'Covariance not included correctly'
     # Write it
     tmpfile = str(tmp_path / '_tst.fits')
     spectrum.write(tmpfile, format='tabular-fits')
 
     # Check the output file
     with fits.open(tmpfile) as hdu:
-        assert len(hdu) == 3, 'Should contain 3 extensions, primary, DATA, CORREL'
-        assert np.array_equal([h.name for h in hdu], ['PRIMARY', 'DATA', 'CORREL']), \
+        assert len(hdu) == 3, 'Should contain 3 extensions, primary, DATA, COVAR'
+        assert np.array_equal([h.name for h in hdu], ['PRIMARY', 'DATA', 'COVAR']), \
                 'Extension names are wrong'
         assert all([h.__class__.__name__ == 'BinTableHDU' for h in hdu[1:]]), \
                 'Data extensions should both be BinTableHDU'
-        assert len(hdu['CORREL'].data) == cov.stored_nnz, \
+        assert len(hdu['COVAR'].data) == cov.stored_nnz, \
                 'Number of non-zero cov elements mismatch'
 
     # Read it
@@ -637,7 +637,9 @@ def test_tabular_fits_cov_io(tmp_path):
     assert spectrum.spectral_axis.unit == _spectrum.spectral_axis.unit
     assert quantity_allclose(spectrum.spectral_axis, _spectrum.spectral_axis)
     assert quantity_allclose(spectrum.flux, _spectrum.flux)
-    assert np.array_equal(spectrum.uncertainty.toarray(), _spectrum.uncertainty.toarray())
+    assert np.array_equal(spectrum.uncertainty.to_dense(), _spectrum.uncertainty.to_dense())
+
+    # TODO: Add test for multidim
 
 
 @pytest.mark.parametrize("ndim", range(1, 4))