cubevis 0.5.14__tar.gz → 0.5.15__tar.gz

{cubevis-0.5.14 → cubevis-0.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cubevis
-Version: 0.5.14
+Version: 0.5.15
 Summary: visualization toolkit and apps for casa
 License: LGPL
 Author-email: Darrell Schiebel <darrell@schiebel.us>,Pam Harris <pharris@nrao.edu>

{cubevis-0.5.14 → cubevis-0.5.15}/cubevis/private/apps/__init__.py

@@ -32,6 +32,11 @@ from cubevis.utils import copydoc, ImportProtectedModule
 from cubevis.bokeh.state import initialize_session
 initialize_session()
 
+###
+### This import roundabout was introduced when astroviper and casa6 apps were in the same
+### package to avoid forcing the user to install BOTH astroviper and casa6 even if they
+### were only going to use one of the applications. Now it could be removed...
+###
 sys.modules[__name__].__class__ = ImportProtectedModule( __name__, { 'plotants': '._plotants',
                                                                      'plotbandpass': '._plotbandpass',
                                                                      'CreateMask': '._createmask',
@@ -40,5 +45,4 @@ sys.modules[__name__].__class__ = ImportProtectedModule( __name__, { 'plotants':
                                                                      'iclean': '..casatasks.iclean',
                                                                      'createmask': '..casatasks.createmask',
                                                                      'createregion': '..casatasks.createregion',
-                                                                     'MsRaster': '._ms_raster',
                                                                    } )

{cubevis-0.5.14 → cubevis-0.5.15}/pyproject.toml

@@ -16,7 +16,7 @@ dependencies = [
 ]
 requires-python = ">=3.10"
 readme = "readme.rst"
-version = "0.5.14"
+version = "0.5.15"
 
 [project.license]
 text = "LGPL"

cubevis-0.5.14/cubevis/data/measurement_set/__init__.py

@@ -1,7 +0,0 @@
-'''
-    Module to access MeasurementSet data using MsData class.
-'''
-
-from ._ms_data import (
-    MsData
-)

cubevis-0.5.14/cubevis/data/measurement_set/_ms_data.py

@@ -1,178 +0,0 @@
-'''
-    Class for accessing and selecting MeasurementSet data using a data backend.
-'''
-
-from cubevis.data.measurement_set.processing_set._ps_data import PsData
-
-class MsData:
-    '''
-    Access and select MeasurementSet data.
-    Current backend implementation is PsData using xradio Processing Set.
-    '''
-
-    def __init__(self, ms_path, logger):
-        self._ms_path = ms_path
-        self._logger = logger
-        self._data = None
-        self._data_initialized = False
-        self._init_data(ms_path)
-
-    def is_valid(self):
-        ''' Returns whether MS path has been set so data can be accessed. '''
-        return self._data_initialized
-
-    def is_ms_path(self, path):
-        ''' Check if input path matches input ms path or zarr path '''
-        return path == self.get_path() or path == self._ms_path
-
-    def get_path(self):
-        ''' Returns path of MS/zarr file or None if not set. '''
-        if self._data_initialized:
-            return self._data.get_path() # path to zarr file
-        if self._ms_path:
-            return self._ms_path # path to ms v2
-        return None
-
-    def summary(self, data_group='base', columns=None):
-        ''' Print summary of Processing Set data.
-                columns (None, str, list): type of metadata to list.
-                    None:      Print all summary columns in ProcessingSet.
-                    'by_msv4': Print formatted summary metadata by MSv4.
-                    str, list: Print a subset of summary columns in ProcessingSet.
-                        Options: 'name', 'intents', 'shape', 'polarization', 'scan_number', 'spw_name',
-                                 'field_name, 'source_name', 'field_coords', 'start_frequency', 'end_frequency'
-        '''
-        # ProcessingSet function
-        if self._data_initialized:
-            self._data.summary(data_group, columns)
-        else:
-            self._log_no_ms()
-
-    def get_ps_summary(self):
-        ''' Return Pandas DataFrame summary of ProcessingSet '''
-        if self._data_initialized:
-            return self._data.get_summary()
-        self._log_no_ms()
-        return None
-
-    def data_groups(self):
-        ''' Returns set of data group names in Processing Set data. '''
-        # ProcessingSet function
-        if self._data_initialized:
-            return self._data.get_data_groups()
-        self._log_no_ms()
-        return None
-
-    def get_antennas(self, plot_positions=False, label_antennas=False):
-        ''' Returns list of antenna names in data.
-                plot_positions (bool): show plot of antenna positions.
-                label_antennas (bool): label positions with antenna names.
-        '''
-        # Antenna positions plot is ProcessingSet function
-        if self._data_initialized:
-            return self._data.get_antennas(plot_positions, label_antennas)
-        self._log_no_ms()
-        return None
-
-    def plot_phase_centers(self, data_group='base', label_all_fields=False):
-        ''' Plot the phase center locations of all fields in the Processing Set (original or selected) and label central field.
-                label_all_fields (bool); label all fields on the plot
-                data_group (str); data group to use for processing.
-        '''
-        # ProcessingSet function
-        if self._data_initialized:
-            self._data.plot_phase_centers(label_all_fields, data_group)
-        else:
-            self._log_no_ms()
-
-    def get_num_ms(self):
-        ''' Returns number of MeasurementSets in data. '''
-        if self._data_initialized:
-            return self._data.get_ps_len()
-        self._log_no_ms()
-        return None
-
-    def get_max_data_dims(self):
-        ''' Returns maximum length of dimensions in data. '''
-        if self._data_initialized:
-            return self._data.get_max_dims()
-        self._log_no_ms()
-        return None
-
-    def get_data_dimensions(self):
-        ''' Returns names of data dimensions. '''
-        if self._data_initialized:
-            return self._data.get_data_dimensions()
-        self._log_no_ms()
-        return None
-
-    def get_dimension_values(self, dim):
-        ''' Return values for dimension in current data.
-                dim (str): dimension name
-        '''
-        if self._data_initialized:
-            return self._data.get_dimension_values(dim)
-        self._log_no_ms()
-        return None
-
-    def get_dimension_attrs(self, dim):
-        ''' Return dict of data attributes for dimension.
-                dim (str): dimension name
-        '''
-        if self._data_initialized:
-            return self._data.get_dimension_attrs(dim)
-        self._log_no_ms()
-        return None
-
-    def get_first_spw(self):
-        ''' Returns name of first spw by id. '''
-        if self._data_initialized:
-            return self._data.get_first_spw()
-        self._log_no_ms()
-        return None
-
-    def select_data(self, selection):
-        ''' Apply selection in data.
-                selection (dict): fields and values to select
-        '''
-        if self._data_initialized:
-            self._data.select_data(selection)
-        else:
-            self._log_no_ms()
-
-    def clear_selection(self):
-        ''' Clears selection dict and selected data. '''
-        if self._data_initialized:
-            self._data.clear_selection()
-
-    def get_vis_stats(self, selection, vis_axis):
-        ''' Returns statistics (min, max, mean, std) for data selected by selection.
-                selection (dict): fields and values to select
-        '''
-        if self._data_initialized:
-            return self._data.get_vis_stats(selection, vis_axis)
-        self._log_no_ms()
-        return None
-
-    def get_correlated_data(self, data_group):
-        ''' Returns name of correlated data variable in Processing Set data group '''
-        if self._data_initialized:
-            return self._data.get_correlated_data(data_group)
-        self._log_no_ms()
-        return None
-
-    def get_raster_data(self, plot_inputs):
-        ''' Returns xarray Dataset after applying plot inputs and raster plane selection '''
-        if self._data_initialized:
-            return self._data.get_raster_data(plot_inputs)
-        self._log_no_ms()
-        return None
-
-    def _log_no_ms(self):
-        self._logger.info("No MS path set, cannot access data")
-
-    def _init_data(self, ms_path):
-        ''' Data backend for MeasurementSet; currently xradio ProcessingSet '''
-        if ms_path:
-            self._data = PsData(ms_path, self._logger)
-            self._data_initialized = True

cubevis-0.5.14/cubevis/data/measurement_set/processing_set/__init__.py

@@ -1,30 +0,0 @@
-'''
-    Module to access MeasurementSet data using xradio ProcessingSetXdt and Xarray objects.
-'''
-
-from ._ps_concat import (
-    concat_ps_xdt,
-)
-
-from ._ps_coords import (
-    set_coordinates,
-    set_datetime_coordinate,
-    set_index_coordinates,
-)
-
-from ._ps_data import (
-    PsData,
-)
-
-from ._ps_io import (
-    get_processing_set,
-)
-
-from ._ps_raster_data import (
-    raster_data,
-)
-
-from ._xds_data import (
-    get_axis_data,
-    get_correlated_data,
-)

cubevis-0.5.14/cubevis/data/measurement_set/processing_set/_ps_concat.py

@@ -1,98 +0,0 @@
-'''
-Concat ProcessingSet xarray DataSets into single xds by time dimension (in order)
-'''
-
-import xarray as xr
-
-from cubevis.data.measurement_set.processing_set._ps_coords import set_coordinates
-
-def concat_ps_xdt(ps_xdt, logger):
-    ''' Concatenate xarray Datasets in ProcessingSet by time dimension.
-        Return concat xds. '''
-    if len(ps_xdt) == 0:
-        raise RuntimeError("Processing set empty after selection.")
-
-    ps = {}
-    for name, ms_xdt in ps_xdt.items():
-        # Set units to str not list and set baseline coordinate.  Returns xarray.Dataset
-        ps[name] = set_coordinates(ms_xdt)
-
-    if len(ps) == 1:
-        logger.debug("Processing set contains one dataset, nothing to concat.")
-        return list(ps.values())[0]
-
-    # Split xds by time gaps
-    sorted_times = _get_sorted_times(ps)
-    xds_list = []
-    time_list = []
-    for xds in ps.values():
-        xdss, times = _split_xds_by_time_gap(xds, sorted_times)
-        xds_list.extend(xdss)
-        time_list.extend(times)
-
-    if len(xds_list) > len(ps_xdt):
-        logger.debug(f"Split {len(ps_xdt)} datasets by time gap into {len(xds_list)} datasets.")
-
-    # Create sorted xds list using sorted times
-    time_list.sort()
-    sorted_xds = [None] * len(time_list)
-
-    for xds in xds_list:
-        try:
-            first_xds_time = xds.time.values[0]
-        except IndexError: # only one value
-            first_xds_time = xds.time.values
-
-        for idx, value in enumerate(time_list):
-            if value == first_xds_time and sorted_xds[idx] is None:
-                if "baseline" in xds.coords:
-                    # Cannot concat with non-dim string coord
-                    xds = xds.drop("baseline_antenna1_name")
-                    xds = xds.drop("baseline_antenna2_name")
-                # Convert MeasurementSetXds to xr Dataset for concat
-                # (TypeError: MeasurementSetXds.__init__() got an unexpected keyword argument 'coords')
-                sorted_xds[idx] = xr.Dataset(xds.data_vars, xds.coords, xds.attrs)
-                break
-    return xr.concat(sorted_xds, dim='time')
-
-def _get_sorted_times(ps):
-    values = []
-    for key in ps:
-        time_values = ps[key].time.values
-        if time_values.size > 1:
-            values.extend(time_values.tolist())
-        else:
-            values.append(time_values)
-    return sorted(values)
-
-def _split_xds_by_time_gap(xds, sorted_times):
-    ''' Split xds where there is a gap in sorted times.
-        Return list of xds and first time in each one. '''
-    times = xds.time.values.ravel()
-    xds_list = []
-    first_times = [times[0]]
-
-    if len(times) == 1:
-        xds_list.append(xds)
-    else:
-        sorted_time_idx = sorted_times.index(times[0])
-        idx = xds_start_idx = 0 # start for iselection
-
-        for idx, time in enumerate(times):
-            if time == sorted_times[sorted_time_idx]:
-                # No time gap, go to next time
-                sorted_time_idx += 1
-                continue
-
-            # Found time gap, select xds
-            xds_list.append(xds.isel(time=slice(xds_start_idx, idx)))
-
-            # start next xds with new first time, find idx in sorted times (skip ahead)
-            xds_start_idx = idx
-            first_times.append(times[idx])
-            sorted_time_idx = sorted_times.index(time) + 1 # for next time
-
-        # add last time range xds
-        xds_list.append(xds.isel(time=slice(xds_start_idx, idx + 1)))
-
-    return xds_list, first_times

cubevis-0.5.14/cubevis/data/measurement_set/processing_set/_ps_coords.py

@@ -1,78 +0,0 @@
-'''
-Modify/add xarray Dataset coordinates for plotting.
-'''
-
-import numpy as np
-from pandas import to_datetime
-
-def set_coordinates(ms_xdt):
-    ''' Convert coordinate units and add baseline coordinate for plotting.
-        Returns xarray.Dataset
-    '''
-    _set_coordinate_unit(ms_xdt)
-    _set_frequency_unit(ms_xdt)
-    return _add_baseline_coordinate(ms_xdt)
-
-def set_datetime_coordinate(ms_xds):
-    ''' Convert float time to datetime for plotting. '''
-    time_attrs = ms_xds.time.attrs
-    try:
-        ms_xds.coords['time'] = to_datetime(ms_xds.time, unit=time_attrs['units'], origin=time_attrs['format'])
-    except TypeError:
-        ms_xds.coords['time'] = to_datetime(ms_xds.time, unit=time_attrs['units'][0], origin=time_attrs['format'])
-    ms_xds.time.attrs = time_attrs
-
-def _set_coordinate_unit(ms_xdt):
-    ''' Set coordinate units attribute as string not list for plotting. '''
-    for coord in ms_xdt.coords:
-        # Plots need unit to be string not list
-        if 'units' in ms_xdt.coords[coord].attrs:
-            units = ms_xdt.coords[coord].units
-            if isinstance(units, list) and len(units) == 1:
-                ms_xdt.coords[coord].attrs['units'] = units[0]
-
-def set_index_coordinates(ms_xds, coordinates):
-    ''' Return ms_xds with new coordinate for string values (name) then replace coordinate with numerical index. '''
-    for coordinate in coordinates:
-        if coordinate == "polarization":
-            ms_xds = ms_xds.assign_coords({"polarization_name": (ms_xds.polarization.dims, ms_xds.polarization.values)})
-            ms_xds["polarization"] = np.array(range(ms_xds.polarization.size))
-        elif coordinate == "baseline":
-            ms_xds = ms_xds.assign_coords({"baseline_name": (ms_xds.baseline.dims, ms_xds.baseline.values)})
-            ms_xds["baseline"] = np.array(range(ms_xds.baseline.size))
-        elif coordinate == "antenna_name":
-            ms_xds = ms_xds.assign_coords({"antenna": (ms_xds.antenna_name.dims, ms_xds.antenna_name.values)})
-            ms_xds["antenna_name"] = np.array(range(ms_xds.antenna_name.size))
-    return ms_xds
-
-def _set_frequency_unit(ms_xdt):
-    ''' Convert frequency to GHz. Note attrs (channel_width, reference_frequency) still have Hz units in dict '''
-    if ms_xdt.frequency.attrs['units'] == "Hz":
-        frequency_xda = ms_xdt.frequency / 1e9
-        frequency_attrs = ms_xdt.frequency.attrs
-        frequency_attrs['units'] = "GHz"
-        frequency_xda = frequency_xda.assign_attrs(frequency_attrs)
-        ms_xdt.coords['frequency'] = frequency_xda
-
-def _add_baseline_coordinate(ms_xdt):
-    '''
-        Replace "baseline_id" (int) with "baseline" (string) coordinate "ant1 & ant2".
-        Baseline ids are not consistent across ms_xdts. 
-    '''
-    # Cannot assign coords to DataTree.
-    baseline_ms_xdt = ms_xdt.to_dataset() # mutable Dataset
-
-    if 'baseline_id' not in baseline_ms_xdt.coords:
-        return baseline_ms_xdt
-
-    ant1_names = ms_xdt.baseline_antenna1_name.values
-    ant2_names = ms_xdt.baseline_antenna2_name.values
-    if ant1_names.size == 1:
-        baseline_names = f"{ant1_names.item()} & {ant2_names.item()}"
-        baseline_ms_xdt = baseline_ms_xdt.assign_coords({"baseline": np.array(baseline_names)})
-    else:
-        baseline_names = [f"{ant1_names[idx]} & {ant2_names[idx]}" for idx in range(len(ant1_names))]
-        baseline_ms_xdt = baseline_ms_xdt.assign_coords({"baseline": ("baseline_id", np.array(baseline_names))})
-        baseline_ms_xdt = baseline_ms_xdt.swap_dims({"baseline_id": "baseline"})
-    baseline_ms_xdt = baseline_ms_xdt.drop("baseline_id")
-    return baseline_ms_xdt

cubevis-0.5.14/cubevis/data/measurement_set/processing_set/_ps_data.py

@@ -1,213 +0,0 @@
-'''
-MeasurementSet data backend using xradio Processing Set.
-'''
-
-import numpy as np
-import pandas as pd
-
-try:
-    from cubevis.data.measurement_set.processing_set._ps_io import get_processing_set
-    _HAVE_XRADIO = True
-    from cubevis.data.measurement_set.processing_set._ps_select import select_ps
-    from cubevis.data.measurement_set.processing_set._ps_stats import calculate_ps_stats
-    from cubevis.data.measurement_set.processing_set._ps_raster_data import raster_data
-    from cubevis.data.measurement_set.processing_set._xds_data import get_correlated_data
-except ImportError as e:
-    _HAVE_XRADIO = False
-
-
-class PsData:
-    '''
-    Class implementing data backend using xradio Processing Set for accessing and selecting MeasurementSet data.
-    '''
-
-    def __init__(self, ms, logger):
-        if not _HAVE_XRADIO:
-            raise RuntimeError("xradio package not available for reading MeasurementSet")
-
-        if not ms:
-            raise RuntimeError("MS path not available for reading MeasurementSet")
-
-        # Open processing set from zarr
-        # Converts msv2 if ms path is not zarr
-        self._ps_xdt, self._zarr_path = get_processing_set(ms, logger)
-
-        self._logger = logger
-        self._selection = {}
-        self._selected_ps_xdt = None # cumulative selection
-
-    def get_path(self):
-        ''' Return path to zarr file (input or converted from msv2) '''
-        return self._zarr_path
-
-    def summary(self, data_group='base', columns=None):
-        ''' Print full or selected summary of Processing Set metadata, optionally by ms '''
-        ps_summary = self._ps_xdt.xr_ps.summary(data_group=data_group)
-        pd.set_option("display.max_rows", len(self._ps_xdt))
-        pd.set_option("display.max_columns", len(ps_summary.columns))
-        pd.set_option("display.max_colwidth", None)
-
-        if columns is None:
-            print(ps_summary)
-        elif columns == "by_ms":
-            for row in ps_summary.itertuples(index=False):
-                print(f"MSv4 name: {row[0]}")
-                print(f"intent: {row[1]}")
-                shape = row[2]
-                print(f"shape: {shape[0]} times, {shape[1]} baselines, {shape[2]} channels, {shape[3]} polarizations")
-                print(f"polarization: {row[3]}")
-                scans = [str(scan) for scan in row[4]]
-                print(f"scan_name: {scans}")
-                print(f"spw_name: {row[5]}")
-                fields = [str(field) for field in row[6]]
-                print(f"field_name: {fields}")
-                sources = [str(source) for source in row[7]]
-                print(f"source_name: {sources}")
-                lines = [str(line) for line in row[8]]
-                print(f"line_name: {lines}")
-                field_coords = row[9]
-                print(f"field_coords: ({field_coords[0]}) {field_coords[1]} {field_coords[2]}")
-                print(f"frequency range: {row[10]:e} - {row[11]:e}")
-                print("-----")
-        else:
-            if isinstance(columns, str):
-                columns = [columns]
-            col_df = ps_summary[columns]
-            print(col_df)
-
-    def get_summary(self):
-        ''' Return summary of original ps '''
-        return self._ps_xdt.xr_ps.summary()
-
-    def get_data_groups(self):
-        ''' Returns set of data group names in Processing Set data. '''
-        data_groups = []
-        for ms_xdt_name in self._ps_xdt:
-            data_groups.extend(list(self._ps_xdt[ms_xdt_name].data_groups))
-        return set(data_groups)
-
-    def get_antennas(self, plot_positions=False, label_antennas=False):
-        ''' Returns list of antenna names in ProcessingSet antenna_xds.
-                plot_positions (bool): show plot of antenna positions.
-                label_antennas (bool): label positions with antenna names.
-        '''
-        if plot_positions:
-            self._ps_xdt.xr_ps.plot_antenna_positions(label_antennas)
-        return self._ps_xdt.xr_ps.get_combined_antenna_xds().antenna_name.values.tolist()
-
-    def plot_phase_centers(self, label_all_fields=False, data_group='base'):
-        ''' Plot the phase center locations of all fields in the Processing Set (original or selected) and label central field.
-                label_all_fields (bool); label all fields on the plot
-                data_group (str); data group to use for processing.
-        '''
-        self._ps_xdt.xr_ps.plot_phase_centers(label_all_fields, data_group)
-
-    def get_ps_len(self):
-        ''' Returns number of ms_xdt in selected ps_xdt (if selected) '''
-        return len(self._get_ps_xdt())
-
-    def get_max_dims(self):
-        ''' Returns maximum length of data dimensions in selected ps_xdt (if selected) '''
-        ps_xdt = self._get_ps_xdt()
-        return ps_xdt.xr_ps.get_max_dims()
-
-    def get_data_dimensions(self):
-        ''' Return the maximum dimensions in selected ps_xdt (if selected) '''
-        dims = list(self.get_max_dims().keys())
-        if 'uvw_label' in dims:
-            dims.remove('uvw_label') # not a VISIBILITY/SPECTRUM data dim
-        return dims
-
-    def get_dimension_values(self, dimension):
-        ''' Return sorted list of unique values for input dimension in ProcessingSet. '''
-        ps_xdt = self._get_ps_xdt()
-        dim_values = []
-        for ms_xdt in ps_xdt.values():
-            if dimension == 'baseline':
-                ant1_names = ms_xdt.baseline_antenna1_name.values
-                ant2_names = ms_xdt.baseline_antenna2_name.values
-                for baseline_id in ms_xdt.baseline_id:
-                    dim_values.append(f"{ant1_names[baseline_id]} & {ant2_names[baseline_id]}")
-            else:
-                try:
-                    dim_values.extend([value.item() for value in ms_xdt[dimension].values])
-                except TypeError:
-                    dim_values.append(ms_xdt[dimension].values.item())
-        return sorted(set(dim_values))
-
-    def get_dimension_attrs(self, dim):
-        ''' Return attributes dict for input dimension in ProcessingSet. '''
-        ps_xdt = self._get_ps_xdt()
-        return ps_xdt.get(0)[dim].attrs
-
-    def get_first_spw(self):
-        ''' Return first spw name by id '''
-        spw_id_names = {}
-        ps_xdt = self._get_ps_xdt()
-        for ms_xdt in ps_xdt.values():
-            freq_xds = ms_xdt.frequency
-            spw_id_names[freq_xds.spectral_window_id] = freq_xds.spectral_window_name
-
-        first_spw_id = min(spw_id_names)
-        first_spw_name = spw_id_names[first_spw_id]
-
-        summary = self.get_summary()
-        spw_df = summary[summary['spw_name'] == first_spw_name]
-        start_freq = spw_df.at[spw_df.index[0], 'start_frequency']
-        end_freq = spw_df.at[spw_df.index[0], 'end_frequency']
-        self._logger.info(f"Selecting first spw {first_spw_name} (id {first_spw_id}) with frequency range {start_freq:e} - {end_freq:e}")
-        return first_spw_name
-
-    def select_data(self, selection):
-        ''' Apply selection dict to ProcessingSet to create selected ps_xdt.
-            If previous selection done, apply to selected ps_xdt.
-            Add selection to previous selections. '''
-        ps_xdt = self._get_ps_xdt()
-        self._selected_ps_xdt = select_ps(ps_xdt, selection, self._logger)
-        if self._selection:
-            self._selection |= selection
-        else:
-            self._selection = selection
-
-    def clear_selection(self):
-        ''' Clear previous selections and use original ps_xdt '''
-        self._selection = None
-        self._selected_ps_xdt = None
-
-    def get_vis_stats(self, selection, vis_axis):
-        ''' Returns statistics (min, max, mean, std) for data selected by selection.
-                selection (dict): fields and values to select
-        '''
-        stats_ps_xdt = select_ps(self._ps_xdt, selection, self._logger)
-        data_group = selection['data_group'] if 'data_group' in selection else 'base'
-        return calculate_ps_stats(stats_ps_xdt, self._zarr_path, vis_axis, data_group, self._logger)
-
-    def get_correlated_data(self, data_group):
-        ''' Returns name of 'correlated_data' in Processing Set data_group '''
-        ps_xdt = self._get_ps_xdt()
-        for ms_xdt in ps_xdt.values():
-            if data_group in ms_xdt.attrs['data_groups']:
-                return get_correlated_data(ms_xdt.ds, data_group)
-        raise RuntimeError(f"No correlated data for data group {data_group}")
-
-    def get_raster_data(self, plot_inputs):
-        ''' Returns xarray Dataset after applying plot inputs and raster plane selection '''
-        return raster_data(self._get_ps_xdt(),
-            plot_inputs,
-            self._logger
-        )
-
-    def _get_ps_xdt(self):
-        ''' Returns selected ps_xdt if selection has been done, else original ps_xdt '''
-        return self._selected_ps_xdt if self._selected_ps_xdt else self._ps_xdt
-
-    def _get_unique_values(self, df_col):
-        ''' Return unique values in pandas Dataframe column, for summary '''
-        values = df_col.to_numpy()
-        try:
-            # numeric arrays
-            return np.unique(np.concatenate(values))
-        except ValueError:
-            # string arrays
-            all_values = [row[0] for row in values]
-            return np.unique(np.concatenate(all_values))