Merge branch 'main' into specutils_16

CHANGES.rst

@@ -5,7 +5,7 @@ New Features
 ------------
 
 - Added flux/surface brightness translation and surface brightness
-  unit conversion in Cubeviz and Specviz. [#2781, #2940, #3088, #3111, #3113, #3129, #3139, #3149, #3155]
+  unit conversion in Cubeviz and Specviz. [#2781, #2940, #3088, #3111, #3113, #3129, #3139, #3149, #3155, #3178]
 
 - Plugin tray is now open by default. [#2892]
 

jdaviz/app.py

@@ -1310,8 +1310,8 @@ def _get_display_unit(self, axis):
                 raise ValueError(f"could not find units for axis='{axis}'")
         uc = self._jdaviz_helper.plugins.get('Unit Conversion')._obj
         if axis == 'spectral_y':
-            # translate options from uc.flux_or_sb to the prefix used in uc.??_unit_selected
-            axis = {'Surface Brightness': 'sb', 'Flux': 'flux'}[uc.flux_or_sb_selected]
+            # translate options from uc.spectral_y_type to the prefix used in uc.??_unit_selected
+            axis = {'Surface Brightness': 'sb', 'Flux': 'flux'}[uc.spectral_y_type_selected]
         try:
             return getattr(uc, f'{axis}_unit_selected')
         except AttributeError:

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

@@ -175,9 +175,9 @@ def _set_data_units(self, event={}):
         self.send_state("output_unit_selected")
 
         # either 'Flux' or 'Surface Brightness'
-        orig_flux_or_sb = self.output_unit_items[0]['label']
+        orig_spectral_y_type = self.output_unit_items[0]['label']
 
-        unit_dict = {orig_flux_or_sb: "",
+        unit_dict = {orig_spectral_y_type: "",
                      "Spectral Unit": "",
                      "Velocity": "km/s",
                      "Velocity^N": f"km{self.n_moment}/s{self.n_moment}"}
@@ -200,19 +200,19 @@ def _set_data_units(self, event={}):
             # get flux/SB units
             if self.spectrum_viewer and hasattr(self.spectrum_viewer.state, 'y_display_unit'):
                 if self.spectrum_viewer.state.y_display_unit is not None:
-                    unit_dict[orig_flux_or_sb] = self.spectrum_viewer.state.y_display_unit
+                    unit_dict[orig_spectral_y_type] = self.spectrum_viewer.state.y_display_unit
                 else:
                     # spectrum_viewer.state will only have x/y_display_unit if unit conversion has
                     # been done if not, get default flux units which should be the units displayed
-                    unit_dict[orig_flux_or_sb] = data.get_component('flux').units
+                    unit_dict[orig_spectral_y_type] = data.get_component('flux').units
             else:
                 # spectrum_viewer.state will only have x/y_display_unit if unit conversion has
                 # been done if not, get default flux units which should be the units displayed
-                unit_dict[orig_flux_or_sb] = data.get_component('flux').units
+                unit_dict[orig_spectral_y_type] = data.get_component('flux').units
 
             # figure out if label should say 'Flux' or 'Surface Brightness'
             sb_or_flux_label = "Flux"
-            is_unit_solid_angle = check_if_unit_is_per_solid_angle(unit_dict[orig_flux_or_sb])
+            is_unit_solid_angle = check_if_unit_is_per_solid_angle(unit_dict[orig_spectral_y_type])
             if is_unit_solid_angle is True:
                 sb_or_flux_label = "Surface Brightness"
 
@@ -353,11 +353,11 @@ def calculate_moment(self, add_data=True):
                 flux_sb_unit = data.get_component('flux').units
 
             # convert unit string to u.Unit so moment map data can be converted
-            flux_or_sb_display_unit = u.Unit(flux_sb_unit)
+            spectral_y_display_unit = u.Unit(flux_sb_unit)
             if SPECUTILS_LT_1_15_1:
-                moment_new_unit = flux_or_sb_display_unit
+                moment_new_unit = spectral_y_display_unit
             else:
-                moment_new_unit = flux_or_sb_display_unit * self.spectrum_viewer.state.x_display_unit  # noqa: E501
+                moment_new_unit = spectral_y_display_unit * self.spectrum_viewer.state.x_display_unit  # noqa: E501
             self.moment = self.moment.to(moment_new_unit)
 
         # Reattach the WCS so we can load the result

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

@@ -275,7 +275,7 @@ def test_momentmap_nirspec_prism(cubeviz_helper, tmp_path):
     uc = cubeviz_helper.plugins["Unit Conversion"]
     uc.open_in_tray()  # plugin has to be open for unit change to take hold
     uc._obj.show_translator = True
-    uc.flux_or_sb.selected = 'Surface Brightness'
+    uc.spectral_y_type.selected = 'Surface Brightness'
     mm = cubeviz_helper.plugins['Moment Maps']._obj
     mm.open_in_tray()  # plugin has to be open for unit change to take hold
     mm._set_data_units()
@@ -289,7 +289,6 @@ def test_momentmap_nirspec_prism(cubeviz_helper, tmp_path):
     assert_allclose((sky_moment.ra.deg, sky_moment.dec.deg),
                     (sky_cube.ra.deg, sky_cube.dec.deg))
 
-
 def test_correct_output_flux_or_sb_units(cubeviz_helper, spectrum1d_cube_custom_fluxunit):
 
     moment_unit = "Jy m / sr"
@@ -309,7 +308,7 @@ def test_correct_output_flux_or_sb_units(cubeviz_helper, spectrum1d_cube_custom_
     uc = cubeviz_helper.plugins["Unit Conversion"]
     uc.open_in_tray()  # plugin has to be open for unit change to take hold
     uc._obj.show_translator = True
-    uc.flux_or_sb.selected = 'Surface Brightness'
+    uc.spectral_y_type.selected = 'Surface Brightness'
     mm = cubeviz_helper.plugins['Moment Maps']._obj
     mm.open_in_tray()  # plugin has to be open for unit change to take hold
     mm._set_data_units()

jdaviz/configs/cubeviz/plugins/tests/test_cubeviz_aperphot.py

@@ -206,7 +206,7 @@ def test_cubeviz_aperphot_unit_conversion(cubeviz_helper, spectrum1d_cube_custom
     # check that initial units are synced between plugins
     assert uc.flux_unit.selected == 'MJy'
     assert uc.angle_unit.selected == 'sr'
-    assert ap.display_flux_or_sb_unit == 'MJy / sr'
+    assert ap.display_spectral_y_unit == 'MJy / sr'
     assert ap.flux_scaling_display_unit == 'MJy'
 
     # and defaults for inputs are in the correct unit

jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.py

@@ -68,7 +68,7 @@ class SimpleAperturePhotometry(PluginTemplateMixin, ApertureSubsetSelectMixin,
     # Cubeviz only
     cube_slice = Unicode("").tag(sync=True)
     is_cube = Bool(False).tag(sync=True)
-    display_flux_or_sb_unit = Unicode("").tag(sync=True)
+    display_spectral_y_unit = Unicode("").tag(sync=True)
     flux_scaling_display_unit = Unicode("").tag(sync=True)
 
     def __init__(self, *args, **kwargs):
@@ -173,7 +173,7 @@ def _on_display_units_changed(self, event={}):
         if self.config == 'cubeviz':
 
             # get previously selected display units
-            prev_display_flux_or_sb_unit = self.display_flux_or_sb_unit
+            prev_display_spectral_y_unit = self.display_spectral_y_unit
             prev_flux_scale_unit = self.flux_scaling_display_unit
 
             # update display unit traitlets to new selection
@@ -182,13 +182,13 @@ def _on_display_units_changed(self, event={}):
             # convert the previous background and flux scaling values to new unit so
             # re-calculating photometry with the current selections will produce
             # the previous output with the new unit.
-            if prev_display_flux_or_sb_unit != '':
+            if prev_display_spectral_y_unit != '':
 
                 # convert background to new unit
                 if self.background_value is not None:
 
-                    prev_unit = u.Unit(prev_display_flux_or_sb_unit)
-                    new_unit = u.Unit(self.display_flux_or_sb_unit)
+                    prev_unit = u.Unit(prev_display_spectral_y_unit)
+                    new_unit = u.Unit(self.display_spectral_y_unit)
 
                     bg = self.background_value * prev_unit
                     self.background_value = bg.to_value(
@@ -206,14 +206,14 @@ def _on_display_units_changed(self, event={}):
     def _set_display_unit_of_selected_dataset(self):
 
         """
-        Set the display_flux_or_sb_unit and flux_scaling_display_unit traitlets,
+        Set the display_spectral_y_unit and flux_scaling_display_unit traitlets,
         which depend on if the selected data set is flux or surface brightness,
         and the corresponding global display unit for either flux or
         surface brightness.
         """
 
         if not self.dataset_selected or not self.aperture_selected:
-            self.display_flux_or_sb_unit = ''
+            self.display_spectral_y_unit = ''
             self.flux_scaling_display_unit = ''
             return
 
@@ -225,13 +225,13 @@ def _set_display_unit_of_selected_dataset(self):
             # if data is something-per-solid-angle, its a SB unit and we should
             # use the selected global display unit for SB
             if check_if_unit_is_per_solid_angle(comp.units):
-                flux_or_sb = 'sb'
+                spectral_y_type = 'sb'
             else:
-                flux_or_sb = 'flux'
+                spectral_y_type = 'flux'
 
-            disp_unit = self.app._get_display_unit(flux_or_sb)
+            disp_unit = self.app._get_display_unit(spectral_y_type)
 
-            self.display_flux_or_sb_unit = disp_unit
+            self.display_spectral_y_unit = disp_unit
 
             # now get display unit for flux_scaling_display_unit. this unit will always
             # be in flux, but it will not be derived from the global flux display unit
@@ -240,7 +240,7 @@ def _set_display_unit_of_selected_dataset(self):
             self.flux_scaling_display_unit = fs_unit.to_string()
 
         else:
-            self.display_flux_or_sb_unit = ''
+            self.display_spectral_y_unit = ''
             self.flux_scaling_display_unit = ''
 
     def _get_defaults_from_metadata(self, dataset=None):
@@ -263,8 +263,8 @@ def _get_defaults_from_metadata(self, dataset=None):
             mjy2abmag = 0.003631
 
             # if display unit is different, translate
-            if (self.config == 'cubeviz') and (self.display_flux_or_sb_unit != ''):
-                disp_unit = u.Unit(self.display_flux_or_sb_unit)
+            if (self.config == 'cubeviz') and (self.display_spectral_y_unit != ''):
+                disp_unit = u.Unit(self.display_spectral_y_unit)
                 mjy2abmag = (mjy2abmag * u.Unit("MJy/sr")).to_value(disp_unit)
 
             if 'photometry' in meta and 'pixelarea_arcsecsq' in meta['photometry']:
@@ -349,7 +349,7 @@ def _dataset_selected_changed(self, event={}):
 
         # get correct display unit for newly selected dataset
         if self.config == 'cubeviz':
-            # set display_flux_or_sb_unit and flux_scaling_display_unit
+            # set display_spectral_y_unit and flux_scaling_display_unit
             self._set_display_unit_of_selected_dataset()
 
         # auto-populate background, if applicable.
@@ -449,9 +449,9 @@ def _calc_background_median(self, reg, data=None):
 
         # convert to display unit, if necessary (cubeviz only)
 
-        if (self.config == 'cubeviz') and (self.display_flux_or_sb_unit != '') and comp.units:
+        if (self.config == 'cubeviz') and (self.display_spectral_y_unit != '') and comp.units:
             bg_md = (bg_md * u.Unit(comp.units)).to_value(
-                u.Unit(self.display_flux_or_sb_unit), u.spectral_density(self._cube_wave))
+                u.Unit(self.display_spectral_y_unit), u.spectral_density(self._cube_wave))
 
         return bg_md
 
@@ -554,7 +554,7 @@ def calculate_photometry(self, dataset=None, aperture=None, background=None,
             img_unit = None
 
         if self.config == 'cubeviz':
-            display_unit = u.Unit(self.display_flux_or_sb_unit)
+            display_unit = u.Unit(self.display_spectral_y_unit)
 
         if background is not None and background not in self.background.choices:  # pragma: no cover
             raise ValueError(f"background must be one of {self.background.choices}")
@@ -734,7 +734,7 @@ def calculate_photometry(self, dataset=None, aperture=None, background=None,
             phot_table.add_column(slice_val, name="slice_wave", index=29)
 
             if comp.units:  # convert phot. results from image unit to display unit
-                display_unit = u.Unit(self.display_flux_or_sb_unit)
+                display_unit = u.Unit(self.display_spectral_y_unit)
                 # convert units of certain columns in aperture phot. output table
                 # to reflect display units (i.e if data units are MJy / sr, but
                 # Jy / sr is selected in Unit Conversion plugin)
@@ -775,8 +775,8 @@ def calculate_photometry(self, dataset=None, aperture=None, background=None,
         if update_plots:
 
             # for cubeviz unit conversion display units
-            if self.display_flux_or_sb_unit != '':
-                plot_display_unit = self.display_flux_or_sb_unit
+            if self.display_spectral_y_unit != '':
+                plot_display_unit = self.display_spectral_y_unit
             else:
                 plot_display_unit = None
 

jdaviz/configs/imviz/plugins/aper_phot_simple/aper_phot_simple.vue

@@ -80,7 +80,7 @@
             v-model.number="background_value"
             type="number"
             hint="Background to subtract"
-            :suffix="display_flux_or_sb_unit"
+            :suffix="display_spectral_y_unit"
             :disabled="background_selected!='Manual'"
             persistent-hint
           >
@@ -191,7 +191,7 @@
     </v-row>
 
     <v-row v-if="!multiselect && plot_available">
-      <jupyter-widget :widget="plot_widget"/> 
+      <jupyter-widget :widget="plot_widget"/>
     </v-row>
 
     <div v-if="!multiselect && plot_available && fit_radial_profile && current_plot_type != 'Curve of Growth'">
@@ -231,7 +231,7 @@
 
     <div v-if="result_available">
       <j-plugin-section-header>Results History</j-plugin-section-header>
-      <jupyter-widget :widget="table_widget"></jupyter-widget> 
+      <jupyter-widget :widget="table_widget"></jupyter-widget>
     </div>
   </j-tray-plugin>
 </template>

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

@@ -89,7 +89,7 @@ def test_conv_no_data(specviz_helper, spectrum1d):
     """plugin unit selections won't have valid choices yet, preventing
     attempting to set display units."""
     # spectrum not load is in Flux units, sb_unit and flux_unit
-    # should be enabled, flux_or_sb should not be
+    # should be enabled, spectral_y_type should not be
     plg = specviz_helper.plugins["Unit Conversion"]
     with pytest.raises(ValueError, match="no valid unit choices"):
         plg.spectral_unit = "micron"
@@ -100,7 +100,7 @@ def test_conv_no_data(specviz_helper, spectrum1d):
     # make sure we don't expose translations in Specviz
     assert hasattr(plg, 'flux_unit')
     assert hasattr(plg, 'angle_unit')
-    assert not hasattr(plg, 'flux_or_sb')
+    assert not hasattr(plg, 'spectral_y_type')
 
 
 def test_non_stddev_uncertainty(specviz_helper):
@@ -150,7 +150,7 @@ def test_unit_translation(cubeviz_helper):
 
     # When the dropdown is displayed, this ensures the loaded
     # data collection item units will be used for translations.
-    assert uc_plg._obj.flux_or_sb_selected == 'Flux'
+    assert uc_plg._obj.spectral_y_type_selected == 'Flux'
 
     # accessing from get_data(use_display_units=True) should return flux-like units
     assert cubeviz_helper.app._get_display_unit('spectral_y') == u.MJy
@@ -161,9 +161,9 @@ def test_unit_translation(cubeviz_helper):
         cubeviz_helper._default_spectrum_viewer_reference_name)
 
     # change global y-units from Flux -> Surface Brightness
-    uc_plg._obj.flux_or_sb_selected = 'Surface Brightness'
+    uc_plg._obj.spectral_y_type_selected = 'Surface Brightness'
 
-    assert uc_plg._obj.flux_or_sb_selected == 'Surface Brightness'
+    assert uc_plg._obj.spectral_y_type_selected == 'Surface Brightness'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
 
     # check if units translated
@@ -190,15 +190,15 @@ def test_sb_unit_conversion(cubeviz_helper):
     uc_plg.open_in_tray()
 
     # ensure that per solid angle cube defaults to Flux spectrum
-    assert uc_plg.flux_or_sb == 'Flux'
+    assert uc_plg.spectral_y_type == 'Flux'
     # flux choices is populated with flux units
     assert uc_plg.flux_unit.choices
 
     # to have access to display units
     viewer_1d = cubeviz_helper.app.get_viewer(
         cubeviz_helper._default_spectrum_viewer_reference_name)
 
-    uc_plg.flux_or_sb.selected = 'Surface Brightness'
+    uc_plg.spectral_y_type.selected = 'Surface Brightness'
 
     # Surface Brightness conversion
     uc_plg.flux_unit = 'Jy'
@@ -243,7 +243,7 @@ def test_sb_unit_conversion(cubeviz_helper):
             "World 13h39m59.7037s +27d00m03.2400s (ICRS)",
             "204.9987654313 27.0008999946 (deg)")
 
-    uc_plg._obj.flux_or_sb_selected = 'Flux'
+    uc_plg._obj.spectral_y_type_selected = 'Flux'
     uc_plg.flux_unit = 'Jy'
     y_display_unit = u.Unit(viewer_1d.state.y_display_unit)
 
@@ -266,7 +266,7 @@ def test_contour_unit_conversion(cubeviz_helper, spectrum1d_cube_fluxunit_jy_per
 
     assert np.allclose(po_plg.contour_max.value, 199)
 
-    uc_plg._obj.flux_or_sb_selected = 'Surface Brightness'
+    uc_plg._obj.spectral_y_type_selected = 'Surface Brightness'
     uc_plg.flux_unit = 'MJy'
 
     assert np.allclose(po_plg.contour_max.value, 1.99e-4)