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

imap_processing/ena_maps/utils/coordinates.py

@@ -0,0 +1,19 @@
+"""Define utils and classes related to coordinates of the ENA maps."""
+
+from enum import Enum
+
+
+class CoordNames(Enum):
+    """Enumeration of the names of the coordinates in the L1C and L2 ENA datasets."""
+
+    GENERIC_PIXEL = "pixel"
+
+    TIME = "epoch"
+    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
+    AZIMUTH_L1C = "longitude"
+    ELEVATION_L1C = "latitude"
+    AZIMUTH_L2 = "longitude"
+    ELEVATION_L2 = "latitude"

imap_processing/ena_maps/utils/map_utils.py

@@ -12,20 +12,22 @@ logger = logging.getLogger(__name__)
 
 def bin_single_array_at_indices(
     value_array: NDArray,
-    projection_grid_shape: tuple[int, int],
+    projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
 ) -> NDArray:
     """
     Bin an array of values at the given indices.
 
+    NOTE: The output array's spatial axis is always the final (-1) axis.
+
     Parameters
     ----------
     value_array : NDArray
-        Array of values to bin. The 0th axis must be the one and only spatial axis.
+        Array of values to bin. The final axis be the one and only spatial axis.
         If other axes are present, they will be binned independently
-        along the 0th (spatial) axis.
-    projection_grid_shape : tuple[int]
+        along the spatial axis.
+    projection_grid_shape : tuple[int, ...]
         The shape of the grid onto which values are projected
         (rows, columns) if the grid is rectangular,
         or just (number of bins,) if the grid is 1D.
@@ -36,7 +38,7 @@ def bin_single_array_at_indices(
         Ordered indices for input grid, corresponding to indices in projection grid.
         1 dimensional. May be non-unique, depending on the projection method.
         If None (default), an arange of the same length as the
-        0th axis of value_array is used.
+        final axis of value_array is used.
 
     Returns
     -------
@@ -52,7 +54,7 @@ def bin_single_array_at_indices(
         If the input value_array has dimensionality less than 1.
     """
     if input_indices is None:
-        input_indices = np.arange(value_array.shape[0])
+        input_indices = np.arange(value_array.shape[-1])
 
     # Both sets of indices must be 1D with the same number of elements
     if input_indices.ndim != 1 or projection_indices.ndim != 1:
@@ -80,23 +82,18 @@ def bin_single_array_at_indices(
         binned_values = np.apply_along_axis(
             lambda x: np.bincount(
                 projection_indices,
-                weights=x[input_indices, ...],
+                weights=x[..., input_indices],
                 minlength=num_projection_indices,
             ),
-            axis=0,
+            axis=-1,
             arr=value_array,
         )
-    else:
-        raise NotImplementedError(
-            "Only 1+ Dimensional arrays are supported for binning. "
-            f"Received array with shape {value_array.shape}."
-        )
     return binned_values
 
 
 def bin_values_at_indices(
     input_values_to_bin: dict[str, NDArray],
-    projection_grid_shape: tuple[int, int],
+    projection_grid_shape: tuple[int, ...],
     projection_indices: NDArray,
     input_indices: NDArray | None = None,
 ) -> dict[str, NDArray]:
@@ -107,10 +104,10 @@ def bin_values_at_indices(
     ----------
     input_values_to_bin : dict[str, NDArray]
         Dict matching variable names to arrays of values to bin.
-        The 0th axis of each array must be the one and only spatial axis,
+        The final (-1) axis of each array must be the one and only spatial axis,
         which the indices correspond to and on which the values will be binned.
-        The other axes will be binned independently along this 0th axis.
-    projection_grid_shape : tuple[int, int]
+        The other axes will be binned independently along this final spatial axis.
+    projection_grid_shape : tuple[int, ...]
         The shape of the grid onto which values are projected (rows, columns).
         This size of the resulting grid (rows * columns) will be the size of the
         projected values contained in the output dictionary.

imap_processing/ena_maps/utils/spatial_utils.py

@@ -15,8 +15,7 @@ def build_spatial_bins(
     """
     Build spatial bin boundaries for azimuth and elevation.
 
-    Input angles in degrees for consistency with map inputs,
-    output angles in radians for internal use.
+    Input/output angles in degrees.
 
     Parameters
     ----------
@@ -28,13 +27,13 @@ def build_spatial_bins(
     Returns
     -------
     az_bin_edges : np.ndarray
-        Array of azimuth bin boundary values in radians.
+        Array of azimuth bin boundary values in degrees.
     el_bin_edges : np.ndarray
-        Array of elevation bin boundary values in radians.
+        Array of elevation bin boundary values in degrees.
     az_bin_midpoints : np.ndarray
-        Array of azimuth bin midpoint values in radians.
+        Array of azimuth bin midpoint values in degrees.
     el_bin_midpoints : np.ndarray
-        Array of elevation bin midpoint values in radians.
+        Array of elevation bin midpoint values in degrees.
     """
     # Azimuth bins from 0 to 360 degrees.
     az_bin_edges = np.arange(0, 360 + az_spacing_deg, az_spacing_deg)
@@ -44,12 +43,11 @@ def build_spatial_bins(
     el_bin_edges = np.arange(-90, 90 + el_spacing_deg, el_spacing_deg)
     el_bin_midpoints = el_bin_edges[:-1] + el_spacing_deg / 2  # Midpoints between edges
 
-    # Convert all angles to radians and return them
     return (
-        np.deg2rad(az_bin_edges),
-        np.deg2rad(el_bin_edges),
-        np.deg2rad(az_bin_midpoints),
-        np.deg2rad(el_bin_midpoints),
+        az_bin_edges,
+        el_bin_edges,
+        az_bin_midpoints,
+        el_bin_midpoints,
     )
 
 
@@ -59,6 +57,10 @@ def build_solid_angle_map(
     """
     Build a solid angle map in steradians for a given spacing in degrees.
 
+    NOTE: This function works in radians internally and returns steradians, while other
+    functions in this module work in degrees. Expressing solid angles in steradians
+    is the preferred unit for ENA Maps.
+
     Parameters
     ----------
     spacing_deg : float
@@ -77,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
@@ -96,23 +103,26 @@ def build_solid_angle_map(
 @typing.no_type_check
 def rewrap_even_spaced_az_el_grid(
     raveled_values: NDArray,
-    shape: tuple[int] | None = None,
+    grid_shape: tuple[int] | None = None,
     order: typing.Literal["C"] | typing.Literal["F"] = "C",
 ) -> NDArray:
     """
     Take an unwrapped (raveled) 1D array and reshapes it into a 2D az/el grid.
 
+    In the input, unwrapped grid, the spatial axis is the final (-1) axis.
+    In the output, the spatial axes are the -2 (azimuth) and -1 (elevation) axes.
+
     Assumes the following must be true of the original grid:
     1. Grid was evenly spaced in angular space,
     2. Grid had the same spacing in both azimuth and elevation.
-    3. Azimuth is axis 0 (and extends a total of 360 degrees).
-    4. Elevation is axis 1 (and extends a total of 180 degrees),
+    3. Azimuth is the first spatial axis (and extends a total of 360 degrees).
+    4. Elevation is the second spatial axis (and extends a total of 180 degrees).
 
     Parameters
     ----------
     raveled_values : NDArray
         1D array of values to be reshaped into a 2D grid.
-    shape : tuple[int], optional
+    grid_shape : tuple[int], optional
         The shape of the original grid, if known, by default None.
         If None, the shape will be inferred from the size of the input array.
     order : {'C', 'F'}, optional
@@ -121,35 +131,27 @@ def rewrap_even_spaced_az_el_grid(
     Returns
     -------
     NDArray
-        The reshaped 2D grid of values.
-
-    Raises
-    ------
-    ValueError
-        If the input is not a 1D array or 2D array with an 'extra' non-spatial axis.
+        The reshaped 2D grid of values with (azimuth, elevation) as the final 2 axes.
     """
-    if raveled_values.ndim > 2:
-        raise ValueError(
-            "Input must be a 1D array or 2D array with only one spatial axis as axis 0."
-        )
-
     # We can infer the shape if its evenly spaced and 2D
-    if not shape:
-        spacing_deg = 1 / np.sqrt(raveled_values.shape[0] / (360 * 180))
-        shape = (int(360 // spacing_deg), int(180 // spacing_deg))
+    if not grid_shape:
+        spacing_deg = 1 / np.sqrt(raveled_values.shape[-1] / (360 * 180))
+        grid_shape = (int(360 // spacing_deg), int(180 // spacing_deg))
 
-    if raveled_values.ndim == 2:
-        shape = (shape[0], shape[1], raveled_values.shape[1])
-    return raveled_values.reshape(shape, order=order)
+    if raveled_values.ndim == 1:
+        array_shape = grid_shape
+    else:
+        array_shape = (*raveled_values.shape[:-1], *grid_shape)
+    return raveled_values.reshape(array_shape, order=order)
 
 
 class AzElSkyGrid:
     """
     Representation of a 2D grid of azimuth and elevation angles covering the sky.
 
-    All angles are stored internally in radians.
-    Azimuth is within the range [0, 2*pi) radians,
-    elevation is within the range [-pi/2, pi/2) radians.
+    All angles are stored internally in degrees.
+    Azimuth is within the range [0, 360) degrees,
+    elevation is within the range [-90, 90) degrees.
 
     Parameters
     ----------
@@ -157,13 +159,13 @@ class AzElSkyGrid:
         Spacing of the grid in degrees, by default 0.5.
     reversed_elevation : bool, optional
         Whether the elevation grid should be reversed, by default False.
-        If False, the elevation grid will be from -pi/2 to pi/2 radians (-90 to 90 deg).
-        If True, the elevation grid will be from pi/2 to -pi/2 radians (90 to -90 deg).
+        If False, the elevation grid will be from -90 to 90 deg.
+        If True, the elevation grid will be from 90 to -90 deg.
 
     Raises
     ------
     ValueError
-        If the spacing is not positive or does not divide evenly into pi radians.
+        If the spacing is not positive or does not divide evenly into 180 degrees.
     """
 
     def __init__(
@@ -174,25 +176,26 @@ class AzElSkyGrid:
         # Store grid properties
         self.reversed_elevation = reversed_elevation
 
-        # Internally, work in radians, regardless of desired output units
-        self.spacing = np.deg2rad(spacing_deg)
+        # Internally, work in degrees
+        self.spacing_deg = spacing_deg
 
-        # Ensure valid grid spacing (positive, divides evenly into pi radians)
-        if self.spacing <= 0:
+        # Ensure valid grid spacing (positive, divides evenly into 180 degrees)
+        if self.spacing_deg <= 0:
             raise ValueError("Spacing must be positive valued, non-zero.")
 
-        if not np.isclose((np.pi / self.spacing) % 1, 0):
-            raise ValueError("Spacing must divide evenly into pi radians.")
+        if not np.isclose((180 / self.spacing_deg) % 1, 0):
+            raise ValueError("Spacing must divide evenly into 180 degrees.")
 
         # build_spacial_bins creates the bin edges and centers for azimuth and elevation
         # E.g. for spacing=1, az_bin_edges = [0, 1, 2, ..., 359, 360] deg.
-        # However returned values are in radians.
         (
             self.az_bin_edges,
             self.el_bin_edges,
             self.az_bin_midpoints,
             self.el_bin_midpoints,
-        ) = build_spatial_bins(az_spacing_deg=spacing_deg, el_spacing_deg=spacing_deg)
+        ) = build_spatial_bins(
+            az_spacing_deg=self.spacing_deg, el_spacing_deg=self.spacing_deg
+        )
 
         # If desired, reverse the elevation range so that the grid is in the order
         # defined by the Ultra prototype code (`build_dps_grid.m`).
@@ -221,6 +224,6 @@ class AzElSkyGrid:
             A string representation of the AzElSkyGrid.
         """
         return (
-            f"AzElSkyGrid with a spacing of {self.spacing:.4e} radians. "
+            f"AzElSkyGrid with a spacing of {self.spacing_deg:.4e} degrees. "
             f"{self.grid_shape} 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,