imap-processing 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

imap_processing/ena_maps/utils/coordinates.py

@@ -9,7 +9,7 @@ class CoordNames(Enum):
     GENERIC_PIXEL = "pixel"
 
     TIME = "epoch"
-    ENERGY = "energy"
+    ENERGY_ULTRA = "energy_bin_geometric_mean"
     HEALPIX_INDEX = "healpix_index"
 
     # The names of the az/el angular coordinates may differ between L1C and L2 data

imap_processing/ena_maps/utils/spatial_utils.py

@@ -79,17 +79,22 @@ def build_solid_angle_map(
     if spacing <= 0:
         raise ValueError("Spacing must be positive valued, non-zero.")
 
-    if not np.isclose((np.pi / spacing) % 1, 0):
+    proposed_number_of_lat_bins = 180 / spacing_deg
+    number_of_lat_bins = round(180 / spacing_deg)
+    number_of_lon_bins = 2 * number_of_lat_bins
+    if not np.isclose(proposed_number_of_lat_bins, number_of_lat_bins):
         raise ValueError("Spacing must divide evenly into pi radians.")
 
-    latitudes = np.arange(-np.pi / 2, np.pi / 2 + spacing, step=spacing)
-    sine_latitudes = np.sin(latitudes)
-    delta_sine_latitudes = np.diff(sine_latitudes)
+    latitude_edges = np.linspace(
+        -np.pi / 2, np.pi / 2, num=number_of_lat_bins + 1, endpoint=True
+    )
+    sine_latitude_edges = np.sin(latitude_edges)
+    delta_sine_latitudes = np.diff(sine_latitude_edges)
     solid_angle_by_latitude = np.abs(spacing * delta_sine_latitudes)
 
     # Order ensures agreement with build_az_el_grid's order of tiling az/el grid.
     solid_angle_grid = np.repeat(
-        solid_angle_by_latitude[np.newaxis, :], (2 * np.pi) / spacing, axis=0
+        solid_angle_by_latitude[np.newaxis, :], number_of_lon_bins, axis=0
     )
 
     return solid_angle_grid

imap_processing/glows/l1a/glows_l1a.py

@@ -1,32 +1,23 @@
 """Methods for GLOWS Level 1A processing and CDF writing."""
 
-from collections import defaultdict
 from pathlib import Path
-from typing import Optional
 
 import numpy as np
 import xarray as xr
 
 from imap_processing.cdf.imap_cdf_manager import ImapCdfAttributes
 from imap_processing.glows.l0.decom_glows import decom_packets
-from imap_processing.glows.l0.glows_l0_data import DirectEventL0, HistogramL0
+from imap_processing.glows.l0.glows_l0_data import DirectEventL0
 from imap_processing.glows.l1a.glows_l1a_data import DirectEventL1A, HistogramL1A
-from imap_processing.glows.l1b.glows_l1b_data import HistogramL1B
 from imap_processing.spice.time import (
-    met_to_datetime64,
     met_to_ttj2000ns,
 )
 
 
-def create_glows_attr_obj(data_version: str) -> ImapCdfAttributes:
+def create_glows_attr_obj() -> ImapCdfAttributes:
     """
     Load in 1la CDF attributes for GLOWS instrument.
 
-    Parameters
-    ----------
-    data_version : str
-        Data version for CDF filename, in the format "vXXX".
-
     Returns
     -------
     glows_attrs : ImapCdfAttributes
@@ -37,23 +28,23 @@ def create_glows_attr_obj(data_version: str) -> ImapCdfAttributes:
     # Load in files
     glows_attrs.add_instrument_global_attrs("glows")
     glows_attrs.add_instrument_variable_attrs("glows", "l1a")
-    glows_attrs.add_global_attribute("Data_version", data_version)
     return glows_attrs
 
 
-def glows_l1a(packet_filepath: Path, data_version: str) -> list[xr.Dataset]:
+def glows_l1a(packet_filepath: Path) -> list[xr.Dataset]:
     """
     Will process packets into GLOWS L1A CDF files.
 
     Outputs Datasets for histogram and direct event GLOWS L1A. This list can be passed
     into write_cdf to output CDF files.
 
+    We expect one input L0 file to be processed into one L1A file, with one
+    observational day's worth of data.
+
     Parameters
     ----------
     packet_filepath : pathlib.Path
         Path to packet file for processing.
-    data_version : str
-        Data version for CDF filename, in the format "vXXX".
 
     Returns
     -------
@@ -61,77 +52,30 @@ def glows_l1a(packet_filepath: Path, data_version: str) -> list[xr.Dataset]:
         List of the L1A datasets.
     """
     # Create ImapCdfAttributes object for cdf attributes management
-    glows_attrs = create_glows_attr_obj(data_version)
-
-    # TODO: Data version inside file as well?
+    glows_attrs = create_glows_attr_obj()
 
     # Decompose packet file into histogram, and direct event data.
     hist_l0, de_l0 = decom_packets(packet_filepath)
 
-    # Create dictionaries to group data by day
-    de_by_day = process_de_l0(de_l0)
-    hists_by_day = defaultdict(list)
-    # Assume the observational day starts with the first packet, then find any new
-    # observation days.
-    # TODO: replace determine_observational_day with spin table API
-    obs_days = [hist_l0[0].SEC]
-    obs_days += determine_observational_day(hist_l0)
-
+    l1a_de = process_de_l0(de_l0)
+    l1a_hists = []
     for hist in hist_l0:
-        hist_l1a = HistogramL1A(hist)
-        # Determine the day the histogram belongs to. This finds the observation
-        # day in obs_day that is nearest the histogram timestamp without going over.
-        hist_day = next(
-            (day for day in reversed(obs_days) if day <= hist.SEC), obs_days[-1]
-        )
-        hists_by_day[hist_day].append(hist_l1a)
+        l1a_hists.append(HistogramL1A(hist))
 
     # Generate CDF files for each day
     output_datasets = []
-    for obs_day, hist_l1a_list in hists_by_day.items():
-        dataset = generate_histogram_dataset(hist_l1a_list, glows_attrs, obs_day)
-        output_datasets.append(dataset)
+    dataset = generate_histogram_dataset(l1a_hists, glows_attrs)
+    output_datasets.append(dataset)
 
-    for de_l1a_list in de_by_day.values():
-        dataset = generate_de_dataset(de_l1a_list, glows_attrs)
-        output_datasets.append(dataset)
+    dataset = generate_de_dataset(l1a_de, glows_attrs)
+    output_datasets.append(dataset)
 
     return output_datasets
 
 
-def determine_observational_day(hist_l0: list[HistogramL0]) -> list:
-    """
-    Find the timestamps for each observational day.
-
-    This function temporarily uses the is_night flag to determine the start of a new
-    observational day, but should eventually use the spin table APIs.
-
-    Parameters
-    ----------
-    hist_l0 : list[HistogramL0]
-        List of HistogramL0 objects.
-
-    Returns
-    -------
-    list
-        List of start times for each observational day.
-    """
-    prev_is_night = -1
-    obs_day_change = []
-    for hist in hist_l0:
-        flags = HistogramL1B.deserialize_flags(hist.FLAGS)
-        is_night: int = int(flags[6])
-        if prev_is_night and not is_night:
-            obs_day_change.append(hist.SEC)
-
-        prev_is_night = is_night
-
-    return obs_day_change
-
-
 def process_de_l0(
     de_l0: list[DirectEventL0],
-) -> dict[np.datetime64, list[DirectEventL1A]]:
+) -> list[DirectEventL1A]:
     """
     Will process Direct Event packets into GLOWS L1A CDF files.
 
@@ -145,25 +89,22 @@ def process_de_l0(
 
     Returns
     -------
-    de_by_day : dict[np.datetime64, list[DirectEventL1A]]
+    de_by_day : list[DirectEventL1A]
         Dictionary with keys of days and values of lists of DirectEventL1A objects.
         Each day has one CDF file associated with it.
     """
-    de_by_day = dict()
+    de_list: list[DirectEventL1A] = []
 
     for de in de_l0:
-        de_day = (met_to_datetime64(de.MET)).astype("datetime64[D]")
-        if de_day not in de_by_day:
-            de_by_day[de_day] = [DirectEventL1A(de)]
         # Putting not first data int o last direct event list.
-        elif de.SEQ != 0:
+        if de.SEQ != 0:
             # If the direct event is part of a sequence and is not the first,
-            # append it to the last direct event in the list
-            de_by_day[de_day][-1].append(de)
+            # add it to the last direct event in the list
+            de_list[-1].merge_de_packets(de)
         else:
-            de_by_day[de_day].append(DirectEventL1A(de))
+            de_list.append(DirectEventL1A(de))
 
-    return de_by_day
+    return de_list
 
 
 def generate_de_dataset(
@@ -263,8 +204,8 @@ def generate_de_dataset(
         support_data["number_of_de_packets"].append(int(de.l0.LEN))
         # support_data["missing_packet_sequences"].append(str(de.missing_seq))
 
-        for key in data_every_second.keys():
-            data_every_second[key].append(de.status_data.__getattribute__(key))
+        for key, val in data_every_second.items():
+            val.append(de.status_data.__getattribute__(key))
 
     # Convert arrays and dictionaries into xarray 'DataArray' objects
     epoch_time = xr.DataArray(
@@ -284,7 +225,6 @@ def generate_de_dataset(
         ),
     )
 
-    # TODO come up with a better name
     within_the_second = xr.DataArray(
         np.arange(direct_events.shape[1]),
         name="within_the_second",
@@ -304,7 +244,6 @@ def generate_de_dataset(
         attrs=glows_cdf_attributes.get_variable_attributes("direct_events"),
     )
 
-    # TODO: This is the weird global attribute.
     # Create an xarray dataset object, and add DataArray objects into it
     output = xr.Dataset(
         coords={"epoch": time_data},
@@ -313,9 +252,6 @@ def generate_de_dataset(
 
     output["direct_events"] = de
 
-    # TODO: Do we want missing_sequences as support data or as global attrs?
-    # Currently: support data, with a string
-
     for key, value in support_data.items():
         output[key] = xr.DataArray(
             value,
@@ -340,7 +276,6 @@ def generate_de_dataset(
 def generate_histogram_dataset(
     hist_l1a_list: list[HistogramL1A],
     glows_cdf_attributes: ImapCdfAttributes,
-    obs_day: Optional[int] = None,
 ) -> xr.Dataset:
     """
     Generate a dataset for GLOWS L1A histogram data CDF files.
@@ -351,9 +286,6 @@ def generate_histogram_dataset(
         List of HistogramL1A objects for a given day.
     glows_cdf_attributes : ImapCdfAttributes
         Object containing l1a CDF attributes for instrument glows.
-    obs_day : int, optional
-        Observational day counter. If supplied, it will be included in the
-        output file name.
 
     Returns
     -------
@@ -407,12 +339,12 @@ def generate_histogram_dataset(
         )
 
         # Add support_data keys to the support_data dictionary
-        for key in support_data.keys():
+        for key, support_val in support_data.items():
             if key not in ["flags_set_onboard", "is_generated_on_ground"]:
-                support_data[key].append(hist.__getattribute__(key))
+                support_val.append(hist.__getattribute__(key))
         # For the time varying data, convert to seconds and then append
-        for key in time_metadata.keys():
-            time_metadata[key].append(hist.__getattribute__(key).to_seconds())
+        for key, time_metadata_val in time_metadata.items():
+            time_metadata_val.append(hist.__getattribute__(key).to_seconds())
         time_data[index] = epoch_time
 
     epoch_time = xr.DataArray(
@@ -450,9 +382,6 @@ def generate_histogram_dataset(
     )
 
     attrs = glows_cdf_attributes.get_global_attributes("imap_glows_l1a_hist")
-    if obs_day:
-        # this needs to be 5 digits, so truncate it from the temporary obs day
-        attrs["Repointing"] = int(str(obs_day)[-5:])
 
     output = xr.Dataset(
         coords={"epoch": epoch_time, "bins": bins, "bins_label": bin_label},

imap_processing/glows/l1a/glows_l1a_data.py

@@ -326,7 +326,7 @@ class DirectEventL1A:
 
     Methods
     -------
-    append
+    merge_de_packets
         Add another Level0 instance.
     """
 
@@ -346,7 +346,7 @@ class DirectEventL1A:
         if level0.LEN == 1:
             self._process_de_data()
 
-    def append(self, second_l0: DirectEventL0) -> None:
+    def merge_de_packets(self, second_l0: DirectEventL0) -> None:
         """
         Merge an additional direct event packet to this DirectEventL1A class.
 

imap_processing/glows/l1b/glows_l1b.py

@@ -10,7 +10,7 @@ from imap_processing.glows import FLAG_LENGTH
 from imap_processing.glows.l1b.glows_l1b_data import DirectEventL1B, HistogramL1B
 
 
-def glows_l1b(input_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+def glows_l1b(input_dataset: xr.Dataset) -> xr.Dataset:
     """
     Will process the GLOWS L1B data and format the output datasets.
 
@@ -18,8 +18,6 @@ def glows_l1b(input_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     ----------
     input_dataset : xr.Dataset
         Dataset of input values.
-    data_version : str
-        Data version.
 
     Returns
     -------
@@ -29,7 +27,6 @@ def glows_l1b(input_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
     cdf_attrs = ImapCdfAttributes()
     cdf_attrs.add_instrument_global_attrs("glows")
     cdf_attrs.add_instrument_variable_attrs("glows", "l1b")
-    cdf_attrs.add_global_attribute("Data_version", data_version)
 
     data_epoch = xr.DataArray(
         input_dataset["epoch"],

imap_processing/glows/l1b/glows_l1b_data.py

@@ -1,4 +1,3 @@
-# ruff: noqa: PLR0913
 """Module for GLOWS L1B data products."""
 
 import dataclasses
@@ -73,8 +72,7 @@ class AncillaryParameters:
 
         except KeyError as e:
             raise KeyError(
-                "GLOWS L1B Ancillary input_table does not conform to "
-                "expected format."
+                "GLOWS L1B Ancillary input_table does not conform to expected format."
             ) from e
 
     def decode(self, param_key: str, encoded_value: np.double) -> np.double:

imap_processing/glows/l2/glows_l2.py

@@ -12,7 +12,7 @@ from imap_processing.glows.l1b.glows_l1b_data import HistogramL1B
 from imap_processing.glows.l2.glows_l2_data import DailyLightcurve, HistogramL2
 
 
-def glows_l2(input_dataset: xr.Dataset, data_version: str) -> list[xr.Dataset]:
+def glows_l2(input_dataset: xr.Dataset) -> list[xr.Dataset]:
     """
     Will process GLoWS L2 data from L1 data.
 
@@ -20,8 +20,6 @@ def glows_l2(input_dataset: xr.Dataset, data_version: str) -> list[xr.Dataset]:
     ----------
     input_dataset : xarray.Dataset
         Input L1B dataset.
-    data_version : str
-        Version for output.
 
     Returns
     -------
@@ -31,7 +29,6 @@ def glows_l2(input_dataset: xr.Dataset, data_version: str) -> list[xr.Dataset]:
     cdf_attrs = ImapCdfAttributes()
     cdf_attrs.add_instrument_global_attrs("glows")
     cdf_attrs.add_instrument_variable_attrs("glows", "l2")
-    cdf_attrs.add_global_attribute("Data_version", data_version)
 
     split_data = split_data_by_observational_day(input_dataset)
     l2_output = []
@@ -270,7 +267,7 @@ def create_l2_dataset(
 
         elif key != "daily_lightcurve":
             val = value
-            if type(value) != np.ndarray:
+            if type(value) is not np.ndarray:
                 val = np.array([value])
             output[key] = xr.DataArray(
                 val,

imap_processing/hi/l1a/hi_l1a.py

@@ -16,7 +16,7 @@ from imap_processing.utils import packet_file_to_datasets
 logger = logging.getLogger(__name__)
 
 
-def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dataset]:
+def hi_l1a(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
     """
     Will process IMAP raw data to l1a.
 
@@ -24,20 +24,13 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
     ----------
     packet_file_path : str
         Data packet file path.
-    data_version : str
-        Version of the data product being created.
 
     Returns
     -------
     processed_data : list[xarray.Dataset]
         List of processed xarray dataset.
     """
-    packet_def_file = (
-        imap_module_directory / "hi/packet_definitions/TLM_HI_COMBINED_SCI.xml"
-    )
-    datasets_by_apid = packet_file_to_datasets(
-        packet_file=packet_file_path, xtce_packet_definition=packet_def_file
-    )
+    datasets_by_apid = hi_packet_file_to_datasets(packet_file_path)
 
     # Process science to l1a.
     processed_data = []
@@ -67,9 +60,6 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
         attr_mgr.add_instrument_global_attrs("hi")
         data.attrs.update(attr_mgr.get_global_attributes(gattr_key))
 
-        # TODO: revisit this
-        data.attrs["Data_version"] = data_version
-
         # set the sensor string in Logical_source
         sensor_str = apid_enum.sensor
         data.attrs["Logical_source"] = data.attrs["Logical_source"].format(
@@ -77,3 +67,32 @@ def hi_l1a(packet_file_path: Union[str, Path], data_version: str) -> list[xr.Dat
         )
         processed_data.append(data)
     return processed_data
+
+
+def hi_packet_file_to_datasets(
+    packet_file_path: Union[str, Path], use_derived_value: bool = False
+) -> dict[int, xr.Dataset]:
+    """
+    Extract hi datasets from packet file.
+
+    Parameters
+    ----------
+    packet_file_path : str
+        L0 packet file path.
+    use_derived_value : bool
+        Whether to use the derived value from the XTCE definition. Default is False.
+
+    Returns
+    -------
+    datasets : dict[int, xarray.Dataset]
+        Dictionary of xarray datasets keyed by APID.
+    """
+    packet_def_file = (
+        imap_module_directory / "hi/packet_definitions/TLM_HI_COMBINED_SCI.xml"
+    )
+    datasets_by_apid = packet_file_to_datasets(
+        packet_file=packet_file_path,
+        xtce_packet_definition=packet_def_file,
+        use_derived_value=use_derived_value,
+    )
+    return datasets_by_apid

imap_processing/hi/l1b/hi_l1b.py

@@ -2,6 +2,8 @@
 
 import logging
 from enum import IntEnum
+from pathlib import Path
+from typing import Union
 
 import numpy as np
 import xarray as xr
@@ -26,7 +28,7 @@ from imap_processing.spice.spin import (
     get_spacecraft_spin_phase,
 )
 from imap_processing.spice.time import met_to_sclkticks, sct_to_et
-from imap_processing.utils import convert_raw_to_eu
+from imap_processing.utils import packet_file_to_datasets
 
 
 class TriggerId(IntEnum):
@@ -43,61 +45,96 @@ ATTR_MGR.add_instrument_global_attrs("hi")
 ATTR_MGR.add_instrument_variable_attrs(instrument="hi", level=None)
 
 
-def hi_l1b(l1a_dataset: xr.Dataset, data_version: str) -> xr.Dataset:
+def hi_l1b(dependency: Union[str, Path, xr.Dataset]) -> list[xr.Dataset]:
     """
     High level IMAP-HI L1B processing function.
 
     Parameters
     ----------
-    l1a_dataset : xarray.Dataset
-        L1A dataset to process.
-    data_version : str
-        Version of the data product being created.
+    dependency : str or xarray.Dataset
+        Path to L0 file or L1A dataset to process.
 
     Returns
     -------
-    l1b_dataset : xarray.Dataset
-        Processed xarray dataset.
+    l1b_dataset : list[xarray.Dataset]
+        Processed xarray datasets.
     """
-    logger.info(
-        f"Running Hi L1B processing on dataset: {l1a_dataset.attrs['Logical_source']}"
-    )
-    logical_source_parts = parse_filename_like(l1a_dataset.attrs["Logical_source"])
-    # TODO: apid is not currently stored in all L1A data but should be.
-    #    Use apid to determine what L1B processing function to call
-
     # Housekeeping processing
-    if logical_source_parts["descriptor"].endswith("hk"):
-        # if packet_enum in (HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK):
-        packet_enum = HIAPID(l1a_dataset["pkt_apid"].data[0])
-        conversion_table_path = str(
-            imap_module_directory / "hi" / "l1b" / "hi_eng_unit_convert_table.csv"
-        )
-        l1b_dataset = convert_raw_to_eu(
-            l1a_dataset,
-            conversion_table_path=conversion_table_path,
-            packet_name=packet_enum.name,
-            comment="#",  # type: ignore[arg-type]
-            # Todo error, Argument "comment" to "convert_raw_to_eu" has incompatible
-            # type "str"; expected "dict[Any, Any]"
-            converters={"mnemonic": str.lower},
-        )
-
-        l1b_dataset.attrs.update(ATTR_MGR.get_global_attributes("imap_hi_l1b_hk_attrs"))
-    elif logical_source_parts["descriptor"].endswith("de"):
-        l1b_dataset = annotate_direct_events(l1a_dataset)
-    else:
-        raise NotImplementedError(
-            f"No Hi L1B processing defined for file type: "
+    if isinstance(dependency, (Path, str)):
+        logger.info(f"Running Hi L1B processing on file: {dependency}")
+        l1b_datasets = housekeeping(dependency)
+    elif isinstance(dependency, xr.Dataset):
+        l1a_dataset = dependency
+        logger.info(
+            f"Running Hi L1B processing on dataset: "
             f"{l1a_dataset.attrs['Logical_source']}"
         )
-    # Update global attributes
-    l1b_dataset.attrs["Logical_source"] = l1b_dataset.attrs["Logical_source"].format(
-        sensor=logical_source_parts["sensor"]
+        logical_source_parts = parse_filename_like(l1a_dataset.attrs["Logical_source"])
+        # TODO: apid is not currently stored in all L1A data but should be.
+        #    Use apid to determine what L1B processing function to call
+
+        # DE processing
+        if logical_source_parts["descriptor"].endswith("de"):
+            l1b_datasets = [annotate_direct_events(l1a_dataset)]
+            l1b_datasets[0].attrs["Logical_source"] = (
+                l1b_datasets[0]
+                .attrs["Logical_source"]
+                .format(sensor=logical_source_parts["sensor"])
+            )
+        else:
+            raise NotImplementedError(
+                f"No Hi L1B processing defined for file type: "
+                f"{l1a_dataset.attrs['Logical_source']}"
+            )
+
+    return l1b_datasets
+
+
+def housekeeping(packet_file_path: Union[str, Path]) -> list[xr.Dataset]:
+    """
+    Will process IMAP raw data to l1b housekeeping dataset.
+
+    In order to use `space_packet_parser` and the xtce which contains the
+    DN to EU conversion factors, the L0 packet file is used to go straight to
+    L1B.
+
+    Parameters
+    ----------
+    packet_file_path : str
+        Packet file path.
+
+    Returns
+    -------
+    processed_data : list[xarray.Dataset]
+        Housekeeping datasets with engineering units.
+    """
+    packet_def_file = (
+        imap_module_directory / "hi/packet_definitions/TLM_HI_COMBINED_SCI.xml"
     )
-    # TODO: revisit this
-    l1b_dataset.attrs["Data_version"] = data_version
-    return l1b_dataset
+    # TODO: If raw and derived values can be gotten from one call to
+    #    packet_file_to_datasets, the L1A and L1B could be generated
+    #    in a single L1A/B function.
+    datasets_by_apid = packet_file_to_datasets(
+        packet_file=packet_file_path,
+        xtce_packet_definition=packet_def_file,
+        use_derived_value=True,
+    )
+
+    # Extract only the HK datasets
+    attr_mgr = ImapCdfAttributes()
+    attr_mgr.add_instrument_global_attrs("hi")
+    datasets = list()
+    for apid in [HIAPID.H45_APP_NHK, HIAPID.H90_APP_NHK]:
+        if apid in datasets_by_apid:
+            datasets.append(datasets_by_apid[apid])
+            # Update the dataset global attributes
+            datasets[-1].attrs.update(
+                ATTR_MGR.get_global_attributes("imap_hi_l1b_hk_attrs")
+            )
+            datasets[-1].attrs["Logical_source"] = (
+                datasets[-1].attrs["Logical_source"].format(sensor=apid.sensor)
+            )
+    return datasets
 
 
 def annotate_direct_events(l1a_dataset: xr.Dataset) -> xr.Dataset: