imap-processing 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

imap_processing/spice/geometry.py

@@ -11,15 +11,12 @@ Paradigms for developing this module:
 
 import typing
 from enum import IntEnum
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
 import spiceypy
 from numpy.typing import NDArray
 
-from imap_processing.spice.kernels import ensure_spice
-
 
 class SpiceBody(IntEnum):
     """Enum containing SPICE IDs for bodies that we use."""
@@ -27,7 +24,7 @@ class SpiceBody(IntEnum):
     # A subset of IMAP Specific bodies as defined in imap_wkcp.tf
     IMAP = -43
     IMAP_SPACECRAFT = -43000
-    # IMAP Pointing Frame (Despun) as defined in imap_science_0001.tf
+    # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
     IMAP_DPS = -43901
     # Standard NAIF bodies
     SOLAR_SYSTEM_BARYCENTER = spiceypy.bodn2c("SOLAR_SYSTEM_BARYCENTER")
@@ -36,13 +33,13 @@ class SpiceBody(IntEnum):
 
 
 class SpiceFrame(IntEnum):
-    """Enum containing SPICE IDs for reference frames, defined in imap_wkcp.tf."""
+    """SPICE IDs for reference frames in imap_wkcp.tf and imap_science_xxx.tf."""
 
     # Standard SPICE Frames
     J2000 = spiceypy.irfnum("J2000")
     ECLIPJ2000 = spiceypy.irfnum("ECLIPJ2000")
     ITRF93 = 13000
-    # IMAP Pointing Frame (Despun) as defined in imap_science_0001.tf
+    # IMAP Pointing Frame (Despun) as defined in imap_science_xxx.tf
     IMAP_DPS = -43901
     # IMAP specific as defined in imap_wkcp.tf
     IMAP_SPACECRAFT = -43000
@@ -61,6 +58,28 @@ class SpiceFrame(IntEnum):
     IMAP_IDEX = -43700
     IMAP_GLOWS = -43750
 
+    # IMAP Science Frames (new additions from imap_science_xxx.tf)
+    IMAP_OMD = -43900
+    IMAP_EARTHFIXED = -43910
+    IMAP_ECLIPDATE = -43911
+    IMAP_MDI = -43912
+    IMAP_MDR = -43913
+    IMAP_GMC = -43914
+    IMAP_GEI = -43915
+    IMAP_GSE = -43916
+    IMAP_GSM = -43917
+    IMAP_SMD = -43918
+    IMAP_RTN = -43920
+    IMAP_HCI = -43921  # HGI_J2K
+    IMAP_HCD = -43922  # HGI_D
+    IMAP_HGC = -43923  # HGS_D
+    IMAP_HAE = -43924
+    IMAP_HAED = -43925
+    IMAP_HEE = -43926
+    IMAP_HRE = -43927
+    IMAP_HNU = -43928
+    IMAP_GCS = -43929
+
 
 BORESIGHT_LOOKUP = {
     SpiceFrame.IMAP_LO_BASE: np.array([0, -1, 0]),
@@ -78,10 +97,8 @@ BORESIGHT_LOOKUP = {
 }
 
 
-@typing.no_type_check
-@ensure_spice
 def imap_state(
-    et: Union[np.ndarray, float],
+    et: np.ndarray | float,
     ref_frame: SpiceFrame = SpiceFrame.ECLIPJ2000,
     abcorr: str = "NONE",
     observer: SpiceBody = SpiceBody.SUN,
@@ -115,14 +132,65 @@ def imap_state(
     return np.asarray(state)
 
 
+def get_instrument_mounting_az_el(instrument: SpiceFrame) -> np.ndarray:
+    """
+    Calculate the azimuth and elevation angle of instrument mounting.
+
+    Azimuth and elevation to instrument mounting in the spacecraft frame.
+    Azimuth is measured in degrees from the spacecraft x-axis. Elevation is measured
+    in degrees from the spacecraft x-y plane.
+
+    Parameters
+    ----------
+    instrument : SpiceFrame
+        Instrument to get the azimuth and elevation angles for.
+
+    Returns
+    -------
+    instrument_mounting_az_el : np.ndarray
+        2-element array containing azimuth and elevation of the instrument
+        mounting in the spacecraft frame. Azimuth is measured in degrees from
+        the spacecraft x-axis. Elevation is measured in degrees from the
+        spacecraft x-y plane.
+    """
+    # Each instrument can have a unique basis vector in the instrument
+    # frame that is used to compute the s/c to instrument mounting.
+    # Most of these vectors are the same as the instrument boresight vector.
+    mounting_normal_vector = {
+        SpiceFrame.IMAP_LO_BASE: np.array([0, -1, 0]),
+        SpiceFrame.IMAP_HI_45: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_HI_90: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_ULTRA_45: np.array([0, 0, 1]),
+        SpiceFrame.IMAP_ULTRA_90: np.array([0, 0, 1]),
+        SpiceFrame.IMAP_MAG: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_SWE: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_SWAPI: np.array([0, 0, -1]),
+        SpiceFrame.IMAP_CODICE: np.array([-1, 0, 0]),
+        SpiceFrame.IMAP_HIT: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_IDEX: np.array([0, 1, 0]),
+        SpiceFrame.IMAP_GLOWS: np.array([0, 0, -1]),
+    }
+
+    # Get the instrument mounting normal vector expressed in the spacecraft frame
+    # The reference frames are fixed, so the et argument can be fixed at 0
+    instrument_normal_sc = frame_transform(
+        0, mounting_normal_vector[instrument], instrument, SpiceFrame.IMAP_SPACECRAFT
+    )
+    # Convert the cartesian coordinate to azimuth/elevation angles in degrees
+    return np.rad2deg(
+        spiceypy.recazl(instrument_normal_sc, azccw=True, elplsz=True)[1:]
+    )
+
+
 def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> float:
     """
     Get the spin phase offset from the spacecraft to the instrument.
 
     For now, the offset is a fixed lookup based on `Table 1: Nominal Instrument
-    to S/C CS Transformations` in document `7516-0011_drw.pdf`. These fixed
-    values will need to be updated based on calibration data or retrieved using
-    SPICE and the latest IMAP frame kernel.
+    to S/C CS Transformations` in document `7516-0011_drw.pdf`. That Table
+    defines the angle from the spacecraft y-axis. We add 90 and take the modulous
+    with 360 in order to get the angle from the spacecraft x-axis. These fixed
+    values will need to be updated based on calibration data.
 
     Parameters
     ----------
@@ -134,26 +202,25 @@ def get_spacecraft_to_instrument_spin_phase_offset(instrument: SpiceFrame) -> fl
     spacecraft_to_instrument_spin_phase_offset : float
         The spin phase offset from the spacecraft to the instrument.
     """
-    # TODO: Implement retrieval from SPICE?
-    offset_lookup = {
-        SpiceFrame.IMAP_LO_BASE: 330 / 360,
-        SpiceFrame.IMAP_HI_45: 255 / 360,
-        SpiceFrame.IMAP_HI_90: 285 / 360,
-        SpiceFrame.IMAP_ULTRA_45: 33 / 360,
-        SpiceFrame.IMAP_ULTRA_90: 210 / 360,
-        SpiceFrame.IMAP_SWAPI: 168 / 360,
-        SpiceFrame.IMAP_IDEX: 90 / 360,
-        SpiceFrame.IMAP_CODICE: 136 / 360,
-        SpiceFrame.IMAP_HIT: 30 / 360,
-        SpiceFrame.IMAP_SWE: 153 / 360,
-        SpiceFrame.IMAP_GLOWS: 127 / 360,
-        SpiceFrame.IMAP_MAG: 0 / 360,
+    phase_offset_lookup = {
+        SpiceFrame.IMAP_LO_BASE: 60 / 360,  # (330 + 90) % 360 = 60
+        SpiceFrame.IMAP_HI_45: 345 / 360,  # 255 + 90 = 345
+        SpiceFrame.IMAP_HI_90: 15 / 360,  # (285 + 90) % 360 = 15
+        SpiceFrame.IMAP_ULTRA_45: 123 / 360,  # 33 + 90 = 123
+        SpiceFrame.IMAP_ULTRA_90: 300 / 360,  # 210 + 90 = 300
+        SpiceFrame.IMAP_SWAPI: 258 / 360,  # 168 + 90 = 258
+        SpiceFrame.IMAP_IDEX: 180 / 360,  # 90 + 90 = 180
+        SpiceFrame.IMAP_CODICE: 226 / 360,  # 136 + 90 = 226
+        SpiceFrame.IMAP_HIT: 120 / 360,  # 30 + 90 = 120
+        SpiceFrame.IMAP_SWE: 243 / 360,  # 153 + 90 = 243
+        SpiceFrame.IMAP_GLOWS: 217 / 360,  # 127 + 90 = 217
+        SpiceFrame.IMAP_MAG: 90 / 360,  # 0 + 90 = 90
     }
-    return offset_lookup[instrument]
+    return phase_offset_lookup[instrument]
 
 
 def frame_transform(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     position: npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
@@ -227,7 +294,7 @@ def frame_transform(
 
 
 def frame_transform_az_el(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     az_el: npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
@@ -276,10 +343,8 @@ def frame_transform_az_el(
     return to_frame_az_el[..., 1:3]
 
 
-@typing.no_type_check
-@ensure_spice
 def get_rotation_matrix(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
 ) -> npt.NDArray:
@@ -317,7 +382,7 @@ def get_rotation_matrix(
 
 
 def instrument_pointing(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     instrument: SpiceFrame,
     to_frame: SpiceFrame,
     cartesian: bool = False,
@@ -355,7 +420,7 @@ def instrument_pointing(
 
 
 def basis_vectors(
-    et: Union[float, npt.NDArray],
+    et: float | npt.NDArray,
     from_frame: SpiceFrame,
     to_frame: SpiceFrame,
 ) -> npt.NDArray:
@@ -528,9 +593,9 @@ def cartesian_to_latitudinal(coords: NDArray, degrees: bool = True) -> NDArray:
 
 
 def solar_longitude(
-    et: Union[np.ndarray, float],
+    et: np.ndarray | float,
     degrees: bool = True,
-) -> Union[float, npt.NDArray]:
+) -> float | npt.NDArray:
     """
     Compute the solar longitude of the Imap Spacecraft.
 

imap_processing/spice/pointing_frame.py

@@ -1,7 +1,6 @@
 """Functions for retrieving repointing table data."""
 
 import logging
-import typing
 from collections.abc import Generator
 from contextlib import contextmanager
 from datetime import datetime, timezone
@@ -13,7 +12,6 @@ from imap_data_access import SPICEFilePath
 from numpy.typing import NDArray
 
 from imap_processing.spice.geometry import SpiceFrame
-from imap_processing.spice.kernels import ensure_spice
 from imap_processing.spice.repoint import get_repoint_data
 from imap_processing.spice.time import (
     TICK_DURATION,
@@ -164,8 +162,6 @@ def write_pointing_frame_ck(
             )
 
 
-@typing.no_type_check
-@ensure_spice
 def calculate_pointing_attitude_segments(
     ck_path: Path,
 ) -> NDArray:
@@ -200,7 +196,7 @@ def calculate_pointing_attitude_segments(
     - Latest NAIF leapseconds kernel (naif0012.tls)
     - The latest IMAP sclk (imap_sclk_NNNN.tsc)
     - The latest IMAP frame kernel (imap_wkcp.tf)
-    - IMAP DPS frame kernel (imap_science_0001.tf)
+    - IMAP DPS frame kernel (imap_science_100.tf)
     - IMAP historical attitude kernel from which the pointing frame kernel will
     be generated.
     """
@@ -292,8 +288,6 @@ def calculate_pointing_attitude_segments(
     return pointing_segments
 
 
-@typing.no_type_check
-@ensure_spice
 def _average_quaternions(et_times: np.ndarray) -> NDArray:
     """
     Average the quaternions.

imap_processing/spice/repoint.py

@@ -3,7 +3,6 @@
 import functools
 import logging
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -113,7 +112,7 @@ def _load_repoint_data_with_cache(csv_path: Path) -> pd.DataFrame:
 
 
 def interpolate_repoint_data(
-    query_met_times: Union[float, npt.NDArray],
+    query_met_times: float | npt.NDArray,
 ) -> pd.DataFrame:
     """
     Interpolate repointing data to the queried MET times.
@@ -194,3 +193,31 @@ def interpolate_repoint_data(
     out_df["repoint_in_progress"] = query_met_times < out_df["repoint_end_met"].values
 
     return out_df
+
+
+def get_pointing_times(met_time: float) -> tuple[float, float]:
+    """
+    Get the start and end MET times for the pointing that contains the query MET time.
+
+    Parameters
+    ----------
+    met_time : float
+        The MET time in a pointing.
+
+    Returns
+    -------
+    pointing_start_time : float
+        The MET time of the repoint maneuver that ends before the query MET time.
+    pointing_end_time : float
+        The MET time of the repoint maneuver that starts after the query MET time.
+    """
+    # Find the pointing start time by finding the repoint end time
+    repoint_df = interpolate_repoint_data(met_time)
+    pointing_start_met = repoint_df["repoint_end_met"].item()
+    # Find the pointing end time by finding the next repoint start time
+    repoint_df = get_repoint_data()
+    pointing_idx = repoint_df.index[
+        repoint_df["repoint_end_met"] == pointing_start_met
+    ][0]
+    pointing_end_met = repoint_df["repoint_start_met"].iloc[pointing_idx + 1].item()
+    return pointing_start_met, pointing_end_met

imap_processing/spice/spin.py

@@ -4,7 +4,6 @@ import functools
 import logging
 from functools import reduce
 from pathlib import Path
-from typing import Union
 
 import numpy as np
 import pandas as pd
@@ -129,7 +128,7 @@ def _load_spin_data_with_cache(csv_paths: tuple[Path]) -> pd.DataFrame:
     return combined_df
 
 
-def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.DataFrame:
+def interpolate_spin_data(query_met_times: float | npt.NDArray) -> pd.DataFrame:
     """
     Interpolate spin table data to the queried MET times.
 
@@ -197,6 +196,10 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
     #   spin_period_valid columns.
     invalid_spin_phase_range = (spin_phases < 0) | (spin_phases >= 1)
 
+    # TODO: add optional to filter this if this flag means
+    # that repointing is happening. otherwise, then keep it.
+    # This needs to be discussed and receive guidance at
+    # the project level.
     invalid_spins = (out_df["spin_phase_valid"].values == 0) | (
         out_df["spin_period_valid"].values == 0
     )
@@ -209,10 +212,31 @@ def interpolate_spin_data(query_met_times: Union[float, npt.NDArray]) -> pd.Data
     return out_df
 
 
+def get_spin_number(met_time: float) -> int:
+    """
+    Get the spin number for the input query time.
+
+    The spin number is the index of the spin table row that contains the
+    spin data for the input query time.
+
+    Parameters
+    ----------
+    met_time : float
+        Query time in Mission Elapsed Time (MET).
+
+    Returns
+    -------
+    spin_number : int
+        Spin number for the input query time.
+    """
+    spin_df = interpolate_spin_data(met_time)
+    return spin_df["spin_number"].item()
+
+
 def get_spin_angle(
-    spin_phases: Union[float, npt.NDArray],
+    spin_phases: float | npt.NDArray,
     degrees: bool = False,
-) -> Union[float, npt.NDArray]:
+) -> float | npt.NDArray:
     """
     Convert spin_phases to radians or degrees.
 
@@ -245,8 +269,8 @@ def get_spin_angle(
 
 
 def get_spacecraft_spin_phase(
-    query_met_times: Union[float, npt.NDArray],
-) -> Union[float, npt.NDArray]:
+    query_met_times: float | npt.NDArray,
+) -> float | npt.NDArray:
     """
     Get the spacecraft spin phase for the input query times.
 
@@ -270,8 +294,8 @@ def get_spacecraft_spin_phase(
 
 
 def get_instrument_spin_phase(
-    query_met_times: Union[float, npt.NDArray], instrument: SpiceFrame
-) -> Union[float, npt.NDArray]:
+    query_met_times: float | npt.NDArray, instrument: SpiceFrame
+) -> float | npt.NDArray:
     """
     Get the instrument spin phase for the input query times.
 

imap_processing/spice/time.py

@@ -3,14 +3,12 @@
 import typing
 from collections.abc import Collection, Iterable
 from datetime import datetime
-from typing import Union
 
 import numpy as np
 import numpy.typing as npt
 import spiceypy
 
 from imap_processing.spice import IMAP_SC_ID
-from imap_processing.spice.kernels import ensure_spice
 
 TICK_DURATION = 2e-5  # 20 microseconds as defined in imap_sclk_0000.tsc
 
@@ -103,7 +101,6 @@ def met_to_ttj2000ns(
 
 
 @typing.no_type_check
-@ensure_spice
 def ttj2000ns_to_et(tt_ns: npt.ArrayLike) -> npt.NDArray[float]:
     """
     Convert TT J2000 epoch nanoseconds to TDB J2000 epoch seconds.
@@ -131,7 +128,6 @@ def ttj2000ns_to_et(tt_ns: npt.ArrayLike) -> npt.NDArray[float]:
 
 
 @typing.no_type_check
-@ensure_spice
 def et_to_ttj2000ns(et: npt.ArrayLike) -> npt.NDArray[float]:
     """
     Convert TDB J2000 epoch seconds to TT J2000 epoch nanoseconds.
@@ -157,7 +153,6 @@ def et_to_ttj2000ns(et: npt.ArrayLike) -> npt.NDArray[float]:
 
 
 @typing.no_type_check
-@ensure_spice(time_kernels_only=True)
 def met_to_utc(met: npt.ArrayLike, precision: int = 9) -> npt.NDArray[str]:
     """
     Convert mission elapsed time (MET) to UTC.
@@ -184,7 +179,7 @@ def met_to_utc(met: npt.ArrayLike, precision: int = 9) -> npt.NDArray[str]:
 
 def met_to_datetime64(
     met: npt.ArrayLike,
-) -> Union[np.datetime64, npt.NDArray[np.datetime64]]:
+) -> np.datetime64 | npt.NDArray[np.datetime64]:
     """
     Convert mission elapsed time (MET) to datetime.datetime.
 
@@ -203,7 +198,7 @@ def met_to_datetime64(
 
 def et_to_datetime64(
     et: npt.ArrayLike,
-) -> Union[np.datetime64, npt.NDArray[np.datetime64]]:
+) -> np.datetime64 | npt.NDArray[np.datetime64]:
     """
     Convert ET to numpy datetime64.
 
@@ -221,10 +216,59 @@ def et_to_datetime64(
 
 
 @typing.no_type_check
-@ensure_spice
+def et_to_met(
+    et: float | Collection[float],
+) -> float | np.ndarray:
+    """
+    Convert ephemeris time to mission elapsed time (MET).
+
+    This function converts ET to spacecraft clock ticks and then to MET seconds.
+    This is the inverse of the MET to ET conversion process.
+
+    Parameters
+    ----------
+    et : Union[float, Collection[float]]
+        Input ephemeris time value(s) to be converted to MET.
+
+    Returns
+    -------
+    met: np.ndarray
+        Mission elapsed time in seconds.
+    """
+    vectorized_sce2c = _vectorize(spiceypy.sce2c, otypes=[float], excluded=[0])
+    sclk_ticks = vectorized_sce2c(IMAP_SC_ID, et)
+    met = np.asarray(sclk_ticks, dtype=float) * TICK_DURATION
+    return met
+
+
+def ttj2000ns_to_met(
+    tt_ns: npt.ArrayLike,
+) -> npt.NDArray[float]:
+    """
+    Convert terrestrial time nanoseconds since J2000 to mission elapsed time (MET).
+
+    This is the inverse of met_to_ttj2000ns. The conversion process is:
+    TTJ2000ns -> ET -> MET
+
+    Parameters
+    ----------
+    tt_ns : float, numpy.ndarray
+        Number of nanoseconds since the J2000 epoch in the TT timescale.
+
+    Returns
+    -------
+    numpy.ndarray[float]
+        The mission elapsed time in seconds.
+    """
+    et = ttj2000ns_to_et(tt_ns)
+    met = et_to_met(et)
+    return met
+
+
+@typing.no_type_check
 def sct_to_et(
-    sclk_ticks: Union[float, Collection[float]],
-) -> Union[float, np.ndarray]:
+    sclk_ticks: float | Collection[float],
+) -> float | np.ndarray:
     """
     Convert encoded spacecraft clock "ticks" to ephemeris time.
 
@@ -247,10 +291,9 @@ def sct_to_et(
 
 
 @typing.no_type_check
-@ensure_spice
 def sct_to_ttj2000s(
-    sclk_ticks: Union[float, Iterable[float]],
-) -> Union[float, np.ndarray]:
+    sclk_ticks: float | Iterable[float],
+) -> float | np.ndarray:
     """
     Convert encoded spacecraft clock "ticks" to terrestrial time (TT).
 
@@ -279,10 +322,9 @@ def sct_to_ttj2000s(
 
 
 @typing.no_type_check
-@ensure_spice
 def str_to_et(
-    time_str: Union[str, Iterable[str]],
-) -> Union[float, np.ndarray]:
+    time_str: str | Iterable[str],
+) -> float | np.ndarray:
     """
     Convert string to ephemeris time.
 
@@ -305,13 +347,12 @@ def str_to_et(
 
 
 @typing.no_type_check
-@ensure_spice
 def et_to_utc(
-    et: Union[float, Iterable[float]],
+    et: float | Iterable[float],
     format_str: str = "ISOC",
     precision: int = 3,
     utclen: int = 24,
-) -> Union[str, np.ndarray]:
+) -> str | np.ndarray:
     """
     Convert ephemeris time to UTC.
 

imap_processing/swapi/l1/swapi_l1.py

@@ -138,7 +138,7 @@ def decompress_count(
 
     # SWAPI suggested using big value to indicate overflow.
     new_count[compressed_indices & (count_data == 0xFFFF)] = np.iinfo(np.int32).max
-    return new_count
+    return (new_count).astype(np.float32)
 
 
 def find_sweep_starts(packets: xr.Dataset) -> npt.NDArray:
@@ -474,6 +474,12 @@ def process_swapi_science(
     swp_scem_counts = decompress_count(raw_scem_count, scem_compression_flags)
     swp_coin_counts = decompress_count(raw_coin_count, coin_compression_flags)
 
+    # Fill first index of 72 steps with nan value per
+    # SWAPI team's instruction. nan helps with plotting.
+    swp_pcem_counts[:, 0] = np.nan
+    swp_scem_counts[:, 0] = np.nan
+    swp_coin_counts[:, 0] = np.nan
+
     # ====================================================
     # Load the CDF attributes
     # ====================================================
@@ -600,17 +606,17 @@ def process_swapi_science(
     )
 
     dataset["swp_pcem_counts"] = xr.DataArray(
-        np.array(swp_pcem_counts, dtype=np.uint16),
+        swp_pcem_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("pcem_counts"),
     )
     dataset["swp_scem_counts"] = xr.DataArray(
-        np.array(swp_scem_counts, dtype=np.uint16),
+        swp_scem_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("scem_counts"),
     )
     dataset["swp_coin_counts"] = xr.DataArray(
-        np.array(swp_coin_counts, dtype=np.uint16),
+        swp_coin_counts,
         dims=["epoch", "esa_step"],
         attrs=cdf_manager.get_variable_attributes("coin_counts"),
     )