expanded support of SB/Flux translations

jdaviz/app.py

@@ -79,17 +79,18 @@ def equivalent_units(self, data, cid, units):
                     'erg / (s cm2)',
                     'erg / (s cm2 Angstrom)', 'erg / (s cm2 Angstrom)',
                     'erg / (s cm2 Hz)', 'erg / (Hz s cm2)',
-                    'ph / (s cm2 Angstrom)', 'ph / (s cm2 Angstrom)',
+                    'ph / (Angstrom s cm2)',
                     'ph / (Hz s cm2)', 'ph / (Hz s cm2)', 'bol', 'AB', 'ST'
                 ]
                 + [
                     'Jy / sr', 'mJy / sr', 'uJy / sr', 'MJy / sr',
                     'W / (Hz sr m2)',
-                    'eV / (s m2 Hz sr)',
-                    'erg / (s cm2 sr)',
-                    'erg / (s cm2 Angstrom sr)', 'erg / (s cm2 Hz sr)',
-                    'ph / (s cm2 Angstrom sr)', 'ph / (s cm2 Hz sr)',
-                    'bol / sr', 'AB / sr', 'ST / sr'
+                    'eV / (Hz s sr m2)',
+                    'erg / (s sr cm2)',
+                    'AB / sr'
+                    # 'erg / (s cm2 Angstrom sr)', 'erg / (Hz s sr cm2)',
+                    # 'ph / (Angstrom s sr cm2)', 'ph / (Hz s sr cm2)',
+                    # 'ST / sr', 'bol / sr'
                 ])
         else:  # spectral axis
             # prefer Hz over Bq and um over micron

jdaviz/configs/cubeviz/plugins/moment_maps/moment_maps.py

@@ -22,8 +22,6 @@
                                         with_spinner)
 from jdaviz.core.validunits import check_if_unit_is_per_solid_angle
 from jdaviz.core.user_api import PluginUserApi
-from jdaviz.utils import flux_conversion
-
 
 __all__ = ['MomentMap']
 
@@ -358,18 +356,7 @@ def calculate_moment(self, add_data=True):
                 moment_new_unit = flux_or_sb_display_unit
             else:
                 moment_new_unit = flux_or_sb_display_unit * self.spectrum_viewer.state.x_display_unit  # noqa: E501
-
-            # Create a temporary Spectrum1D object with ability to convert from surface brightness
-            # to flux
-            temp_spec = Spectrum1D(flux=self.moment)
-            flux_values = np.sum(np.ones_like(temp_spec.flux.value), axis=(0, 1))
-            pix_scale = self.dataset.selected_dc_item.meta.get('PIXAR_SR', 1.0)
-            pix_scale_factor = (flux_values * pix_scale)
-            temp_spec.meta['_pixel_scale_factor'] = pix_scale_factor
-            converted_spec = flux_conversion(temp_spec, self.moment.value,
-                                             self.moment.unit,
-                                             moment_new_unit) * moment_new_unit
-            self.moment = converted_spec
+            self.moment = self.moment.to(moment_new_unit)
 
         # Reattach the WCS so we can load the result
         self.moment = CCDData(self.moment, wcs=data_wcs)

jdaviz/configs/cubeviz/plugins/moment_maps/tests/test_moment_maps.py

@@ -334,7 +334,7 @@ def test_correct_output_flux_or_sb_units(cubeviz_helper, spectrum1d_cube_custom_
 
     # now change surface brightness units in the unit conversion plugin
 
-    uc.flux_or_sb_unit = 'Jy / sr'
+    uc.sb_unit = 'Jy / sr'
 
     # and make sure this change is propogated
     output_unit_moment_0 = mm.output_unit_items[0]
@@ -344,21 +344,3 @@ def test_correct_output_flux_or_sb_units(cubeviz_helper, spectrum1d_cube_custom_
     # and that calculated moment has the correct units
     mm.calculate_moment()
     assert mm.moment.unit == moment_unit
-
-    uc.flux_or_sb.selected = 'Flux'
-    mm._set_data_units()
-
-    # and make sure this change is propogated
-    output_unit_moment_0 = mm.output_unit_items[0]
-    assert output_unit_moment_0['label'] == 'Flux'
-    assert output_unit_moment_0['unit_str'] == 'Jy'
-
-    # TODO: Failing because of dev version of upstream dependency, figure
-    #  out which one
-    # assert mm.calculate_moment()
-
-    # TODO: This test should pass once continuum subtraction works with
-    #  flux to surface brightness conversion
-    # mm.continuum.selected = 'Surrounding'
-    #
-    # assert mm.calculate_moment()

jdaviz/configs/cubeviz/plugins/spectral_extraction/spectral_extraction.py

@@ -497,6 +497,15 @@ def extract(self, return_bg=False, add_data=True, **kwargs):
         pix_scale_factor = self.aperture_area_along_spectral * self.spectral_cube.meta.get('PIXAR_SR', 1.0)  # noqa
         spec.meta['_pixel_scale_factor'] = pix_scale_factor
 
+        # inform the user if scale factor keyword not in metadata
+        if 'PIXAR_SR' not in self.spectral_cube.meta:
+            snackbar_message = SnackbarMessage(
+                ("PIXAR_SR FITS header keyword not found when parsing spectral cube. "
+                 "Flux/Surface Brightness will use default scale factor of 1."),
+                color="error",
+                sender=self)
+            self.hub.broadcast(snackbar_message)
+
         # stuff for exporting to file
         self.extracted_spec = spec
         self.extracted_spec_available = True

jdaviz/configs/imviz/plugins/coords_info/coords_info.py

@@ -562,8 +562,9 @@ def _copy_axes_to_spectral():
                 if '_pixel_scale_factor' in sp.meta:
                     eqv = [(u.MJy / u.sr,
                             u.MJy,
-                            lambda x: (x * sp.meta['_pixel_scale_factor']),
+                            lambda x: (x * np.array(sp.meta.get('_pixel_scale_factor', 1))),
                             lambda x: x)]
+                    eqv += u.spectral_density(sp.spectral_axis)
                     disp_flux = sp.flux.to_value(viewer.state.y_display_unit, eqv)
                 else:
                     disp_flux = sp.flux.to_value(viewer.state.y_display_unit,

jdaviz/configs/specviz/plugins/unit_conversion/tests/test_unit_conversion.py

@@ -140,23 +140,9 @@ def test_unit_translation(cubeviz_helper):
     cubeviz_helper.load_regions(CirclePixelRegion(center, radius=2.5))
 
     uc_plg = cubeviz_helper.plugins['Unit Conversion']
-    # we can get rid of this after all spectra pass through
-    # spectral extraction plugin
-    extract_plg = cubeviz_helper.plugins['Spectral Extraction']
-
-    extract_plg.aperture = extract_plg.aperture.choices[-1]
-    extract_plg.aperture_method.selected = 'Exact'
-    extract_plg.wavelength_dependent = True
-    extract_plg.function = 'Sum'
-    # set so pixel scale factor != 1
-    extract_plg.reference_spectral_value = 0.000001
-
-    # all spectra will pass through spectral extraction,
-    # this will store a scale factor for use in translations.
-    collapsed_spec = extract_plg.extract()
 
     # test that the scale factor was set
-    assert np.all(collapsed_spec.meta['_pixel_scale_factor'] != 1)
+    assert np.all(cubeviz_helper.app.data_collection[-1].meta['_pixel_scale_factor'] != 1)
 
     # When the dropdown is displayed, this ensures the loaded
     # data collection item units will be used for translations.
@@ -167,13 +153,9 @@ def test_unit_translation(cubeviz_helper):
     viewer_1d = cubeviz_helper.app.get_viewer(
         cubeviz_helper._default_spectrum_viewer_reference_name)
 
-    #  for testing _set_flux_or_sb()
-    uc_plg._obj.show_translator = False
-
     # change global y-units from Flux -> Surface Brightness
     uc_plg._obj.flux_or_sb_selected = 'Surface Brightness'
 
-    uc_plg._obj.show_translator = True
     assert uc_plg._obj.flux_or_sb_selected == 'Surface Brightness'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
 
@@ -204,34 +186,24 @@ def test_sb_unit_conversion(cubeviz_helper):
     uc_plg.flux_or_sb.selected = 'Surface Brightness'
 
     # Surface Brightness conversion
-    uc_plg.flux_or_sb_unit = 'Jy / sr'
+    uc_plg.sb_unit = 'Jy / sr'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
     assert y_display_unit == u.Jy / u.sr
 
     # Try a second conversion
-    uc_plg.flux_or_sb_unit = 'W / Hz sr m2'
+    uc_plg.sb_unit = 'W / Hz sr m2'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
     assert y_display_unit == u.Unit("W / (Hz sr m2)")
 
     # really a translation test, test_unit_translation loads a Flux
     # cube, this test load a Surface Brightness Cube, this ensures
     # two-way translation
-    uc_plg.flux_or_sb_unit = 'MJy / sr'
+    uc_plg.sb_unit = 'MJy / sr'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
 
-    # we can get rid of this after all spectra pass through
-    # spectral extraction plugin
-    extract_plg = cubeviz_helper.plugins['Spectral Extraction']
-    extract_plg.aperture = extract_plg.aperture.choices[-1]
-    extract_plg.aperture_method.selected = 'Exact'
-    extract_plg.wavelength_dependent = True
-    extract_plg.function = 'Sum'
-    extract_plg.reference_spectral_value = 0.000001
-    extract_plg.extract()
-
     uc_plg._obj.show_translator = True
     uc_plg._obj.flux_or_sb_selected = 'Flux'
-    uc_plg.flux_or_sb_unit = 'MJy'
+    uc_plg.flux_unit = 'MJy'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
 
     assert y_display_unit == u.MJy