imap-processing 0.16.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

imap_processing/hit/l2/constants.py

@@ -169,7 +169,7 @@ STANDARD_PARTICLE_ENERGY_RANGE_MAPPING = {
         {"energy_min": 5.0, "energy_max": 6.0, "R2": [59], "R3": [], "R4": []},
         {"energy_min": 6.0, "energy_max": 8.0, "R2": [60], "R3": [63], "R4": []},
         {"energy_min": 8.0, "energy_max": 10.0, "R2": [61], "R3": [64], "R4": []},
-        {"energy_min": 10.0, "energy_max": 12.0, "R2": [], "R3": [65], "R4": []},
+        {"energy_min": 10.0, "energy_max": 12.0, "R2": [62], "R3": [65], "R4": []},
         {"energy_min": 12.0, "energy_max": 15.0, "R2": [], "R3": [66], "R4": []},
         {"energy_min": 15.0, "energy_max": 21.0, "R2": [], "R3": [67], "R4": []},
         {"energy_min": 21.0, "energy_max": 27.0, "R2": [], "R3": [68], "R4": []},

imap_processing/hit/l2/hit_l2.py

@@ -95,11 +95,11 @@ def add_cdf_attributes(
 
     Parameters
     ----------
-    dataset : xr.Dataset
+    dataset : xarray.Dataset
         The dataset to update.
     logical_source : str
         The logical source of the dataset.
-    attr_mgr : AttributeManager
+    attr_mgr : ImapCdfAttributes
         The attribute manager to retrieve attributes.
 
     Returns
@@ -132,7 +132,6 @@ def add_cdf_attributes(
     # check_schema=False to avoid attr_mgr adding stuff dimensions don't need
     for dim in dataset.dims:
         dataset[dim].attrs = attr_mgr.get_variable_attributes(dim, check_schema=False)
-        # TODO: should labels be added as coordinates? Check with SPDF
         if dim != "epoch":
             label_array = xr.DataArray(
                 dataset[dim].values.astype(str),
@@ -312,6 +311,7 @@ def calculate_intensities_for_a_species(
         The updated dataset with intensities calculated for the given species.
     """
     updated_ds = l2_dataset.copy()
+    # Get the dynamic threshold state for the species variable
     dynamic_threshold_states = updated_ds["dynamic_threshold_state"].values
     unique_states = np.unique(dynamic_threshold_states)
     species_name = (
@@ -632,7 +632,7 @@ def process_summed_intensity(
             summed_intensity_dataset = add_total_uncertainties(
                 summed_intensity_dataset, var
             )
-            # Expand the variable name to include standard intensity
+            # Expand the variable name to include summed intensity
             summed_intensity_dataset = summed_intensity_dataset.rename(
                 {var: f"{var}_summed_intensity"}
             )

imap_processing/ialirt/constants.py

@@ -1,6 +1,7 @@
 """Module for constants and useful shared classes used in I-ALiRT processing."""
 
 from dataclasses import dataclass
+from typing import NamedTuple
 
 import numpy as np
 
@@ -36,3 +37,23 @@ class IalirtSwapiConstants:
     az_fov = np.deg2rad(30)  # azimuthal width of the field of view, radians
     fwhm_width = 0.085  # FWHM of energy width
     speed_ew = 0.5 * fwhm_width  # speed width of energy passband
+
+
+class StationProperties(NamedTuple):
+    """Class that represents properties of ground stations."""
+
+    longitude: float  # longitude in degrees
+    latitude: float  # latitude in degrees
+    altitude: float  # altitude in kilometers
+    min_elevation_deg: float  # minimum elevation angle in degrees
+
+
+# Verified by Kiel Observatory staff.
+STATIONS = {
+    "Kiel": StationProperties(
+        longitude=10.1808,  # degrees East
+        latitude=54.2632,  # degrees North
+        altitude=0.1,  # approx 100 meters
+        min_elevation_deg=5,  # 5 degrees is the requirement
+    )
+}

imap_processing/ialirt/generate_coverage.py

@@ -0,0 +1,188 @@
+"""Coverage time for each station."""
+
+import logging
+
+import numpy as np
+
+from imap_processing.ialirt.constants import STATIONS
+from imap_processing.ialirt.process_ephemeris import calculate_azimuth_and_elevation
+from imap_processing.spice.time import et_to_utc, str_to_et
+
+# Logger setup
+logger = logging.getLogger(__name__)
+
+# TODO: get a list of all potential DSN stations.
+ALL_STATIONS = [*STATIONS.keys(), "DSS-55", "DSS-56", "DSS-74", "DSS-75"]
+
+
+def generate_coverage(
+    start_time: str,
+    outages: dict | None = None,
+    dsn: dict | None = None,
+) -> tuple[dict, dict]:
+    """
+    Build the output dictionary containing coverage and outage time for each station.
+
+    Parameters
+    ----------
+    start_time : str
+        Start time in UTC.
+    outages : dict, optional
+        Dictionary of outages for each station.
+    dsn : dict, optional
+        Dictionary of Deep Space Network (DSN) stations.
+
+    Returns
+    -------
+    coverage_dict : dict
+        Visibility times per station.
+    outage_dict : dict
+        Outage times per station.
+    """
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    stations = {
+        "Kiel": STATIONS["Kiel"],
+    }
+    coverage_dict = {}
+    outage_dict = {}
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    total_visible_mask = np.zeros(time_range.shape, dtype=bool)
+
+    # Precompute DSN outage mask for non-DSN stations
+    dsn_outage_mask = np.zeros(time_range.shape, dtype=bool)
+    if dsn:
+        for dsn_contacts in dsn.values():
+            for start, end in dsn_contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                dsn_outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+    for station_name, (lon, lat, alt, min_elevation) in stations.items():
+        azimuth, elevation = calculate_azimuth_and_elevation(lon, lat, alt, time_range)
+        visible = elevation > min_elevation
+
+        outage_mask = np.zeros(time_range.shape, dtype=bool)
+        if outages and station_name in outages:
+            for start, end in outages[station_name]:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+        visible[outage_mask] = False
+        # DSN contacts block other stations
+        visible[dsn_outage_mask] = False
+        total_visible_mask |= visible
+
+        coverage_dict[station_name] = et_to_utc(time_range[visible], format_str="ISOC")
+        outage_dict[station_name] = et_to_utc(
+            time_range[outage_mask], format_str="ISOC"
+        )
+
+    # --- DSN Stations ---
+    if dsn:
+        for dsn_station, contacts in dsn.items():
+            dsn_visible_mask = np.zeros(time_range.shape, dtype=bool)
+            for start, end in contacts:
+                start_et = str_to_et(start)
+                end_et = str_to_et(end)
+                dsn_visible_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            # Apply DSN outages if present
+            outage_mask = np.zeros(time_range.shape, dtype=bool)
+            if outages and dsn_station in outages:
+                for start, end in outages[dsn_station]:
+                    start_et = str_to_et(start)
+                    end_et = str_to_et(end)
+                    outage_mask |= (time_range >= start_et) & (time_range <= end_et)
+
+            dsn_visible_mask[outage_mask] = False
+            total_visible_mask |= dsn_visible_mask
+
+            coverage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[dsn_visible_mask], format_str="ISOC"
+            )
+            outage_dict[f"{dsn_station}"] = et_to_utc(
+                time_range[outage_mask], format_str="ISOC"
+            )
+
+    # Total coverage percentage
+    total_coverage_percent = (
+        np.count_nonzero(total_visible_mask) / time_range.size
+    ) * 100
+    coverage_dict["total_coverage_percent"] = total_coverage_percent
+
+    # Ensure all stations are present in both dicts
+    for station in ALL_STATIONS:
+        coverage_dict.setdefault(station, np.array([], dtype="<U23"))
+        outage_dict.setdefault(station, np.array([], dtype="<U23"))
+
+    return coverage_dict, outage_dict
+
+
+def format_coverage_summary(
+    coverage_dict: dict, outage_dict: dict, start_time: str
+) -> dict:
+    """
+    Build the output dictionary containing coverage time for each station.
+
+    Parameters
+    ----------
+    coverage_dict : dict
+        Coverage for each station, keyed by station name with arrays of UTC times.
+    outage_dict : dict
+        Outage times for each station, keyed by station name with arrays of UTC times.
+    start_time : str
+        Start time in UTC.
+
+    Returns
+    -------
+    output_dict : dict
+        Formatted coverage summary.
+    """
+    # Include all known stations,
+    # plus any new ones that appear in coverage_dict.
+    all_stations = ALL_STATIONS + [
+        station
+        for station in coverage_dict.keys()
+        if station not in ALL_STATIONS and station != "total_coverage_percent"
+    ]
+
+    duration_seconds = 24 * 60 * 60  # 86400 seconds in 24 hours
+    time_step = 3600  # 1 hr in seconds
+
+    start_et_input = str_to_et(start_time)
+    stop_et_input = start_et_input + duration_seconds
+
+    time_range = np.arange(start_et_input, stop_et_input, time_step)
+    all_times = et_to_utc(time_range, format_str="ISOC")
+
+    data_rows = []
+    for time in all_times:
+        row = {"time": time}
+        for station in all_stations:
+            visible_times = coverage_dict.get(station, [])
+            outage_times = outage_dict.get(station, [])
+            if time in outage_times:
+                row[station] = "X"
+            elif time in visible_times:
+                row[station] = "1"
+            else:
+                row[station] = "0"
+        data_rows.append(row)
+
+    output_dict = {
+        "summary": "I-ALiRT Coverage Summary",
+        "generated": start_time,
+        "time_format": "UTC (ISOC)",
+        "stations": all_stations,
+        "total_coverage_percent": round(coverage_dict["total_coverage_percent"], 1),
+        "data": data_rows,
+    }
+
+    return output_dict

imap_processing/ialirt/l0/parse_mag.py

@@ -20,6 +20,8 @@ from imap_processing.mag.l1b.mag_l1b import (
     calibrate_vector,
     shift_time,
 )
+from imap_processing.mag.l1d.mag_l1d_data import MagL1d
+from imap_processing.mag.l2.mag_l2_data import MagL2L1dBase
 from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
 
 logger = logging.getLogger(__name__)
@@ -286,6 +288,56 @@ def calculate_l1b(
     return updated_vector_mago, updated_vector_magi, time_data
 
 
+def calibrate_and_offset_vectors(
+    vectors: np.ndarray,
+    range_vals: np.ndarray,
+    calibration: np.ndarray,
+    offsets: np.ndarray,
+    is_magi: bool = False,
+) -> np.ndarray:
+    """
+    Apply calibration and offsets to magnetic vectors.
+
+    Parameters
+    ----------
+    vectors : np.ndarray
+        Raw magnetic vectors, shape (n, 3).
+    range_vals : np.ndarray
+        Range indices for each vector, shape (n). Values 0–3.
+    calibration : np.ndarray
+        Calibration matrix, shape (3, 3, 4).
+    offsets : np.ndarray
+        Offsets array, shape (2, 4, 3) where:
+        - index 0 = MAGo, 1 = MAGi
+        - second index = range (0–3)
+        - third index = axis (x, y, z)
+    is_magi : bool, optional
+        True if applying to MAGi data, False for MAGo.
+
+    Returns
+    -------
+    calibrated_and_offset_vectors : np.ndarray
+        Calibrated and offset vectors, shape (n, 3).
+    """
+    # Append range as 4th column
+    vec_plus_range = np.concatenate((vectors, range_vals[:, np.newaxis]), axis=1)
+
+    # Apply calibration matrix -> (n,4)
+    calibrated = MagL2L1dBase.apply_calibration(vec_plus_range, calibration)
+
+    # Apply offsets per vector
+    # vec shape (4)
+    # offsets shape (2, 4, 3) where first index is 0 for MAGo and 1 for MAGi
+    calibrated = np.array(
+        [
+            MagL1d.apply_calibration_offset_single_vector(vec, offsets, is_magi=is_magi)
+            for vec in calibrated
+        ]
+    )
+
+    return calibrated[:, :3]
+
+
 def process_packet(
     accumulated_data: xr.Dataset, calibration_dataset: xr.Dataset
 ) -> tuple[list[dict], list[dict]]:
@@ -392,11 +444,16 @@ def process_packet(
                 "met": int(met.values.min()),
                 "met_in_utc": met_to_utc(met.values.min()).split(".")[0],
                 "ttj2000ns": int(met_to_ttj2000ns(met.values.min())),
-                "mag_4s_b_gse": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_gsm": [Decimal("0.0") for _ in range(3)],
-                "mag_4s_b_rtn": [Decimal("0.0") for _ in range(3)],
-                "mag_phi_4s_b_gsm": Decimal("0.0"),
-                "mag_theta_4s_b_gsm": Decimal("0.0"),
+                # TODO: Placeholder for mag_epoch
+                "mag_epoch": int(met.values.min()),
+                "mag_B_GSE": [Decimal("0.0") for _ in range(3)],
+                "mag_B_GSM": [Decimal("0.0") for _ in range(3)],
+                "mag_B_RTN": [Decimal("0.0") for _ in range(3)],
+                "mag_B_magnitude": Decimal("0.0"),
+                "mag_phi_B_GSM": Decimal("0.0"),
+                "mag_theta_B_GSM": Decimal("0.0"),
+                "mag_phi_B_GSE": Decimal("0.0"),
+                "mag_theta_B_GSE": Decimal("0.0"),
             }
         )
 

imap_processing/ialirt/l0/process_swapi.py

@@ -96,7 +96,7 @@ def optimize_pseudo_parameters(
         # Read in energy passbands
         energy_data = pd.read_csv(
             f"{imap_module_directory}/tests/swapi/lut/imap_swapi_esa-unit"
-            f"-conversion_20250211_v000.csv"
+            f"-conversion_20250626_v001.csv"
         )
         energy_passbands = (
             energy_data["Energy"][0:63]

imap_processing/ialirt/l0/process_swe.py

@@ -542,16 +542,32 @@ def process_swe(accumulated_data: xr.Dataset, in_flight_cal_files: list) -> list
         summed_first = normalized_first_half.sum(axis=(1, 2))
         summed_second = normalized_second_half.sum(axis=(1, 2))
 
+        met_first_half = int(
+            grouped["met"].where(grouped["swe_seq"] == 0, drop=True).values[0]
+        )
+        met_second_half = int(
+            grouped["met"].where(grouped["swe_seq"] == 30, drop=True).values[0]
+        )
+
+        swe_data.append(
+            {
+                "apid": 478,
+                "met": met_first_half,
+                "met_in_utc": met_to_utc(met_first_half).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_first_half)),
+                "swe_normalized_counts": [int(val) for val in summed_first],
+                "swe_counterstreaming_electrons": bde_first_half,
+            },
+        )
         swe_data.append(
             {
                 "apid": 478,
-                "met": int(grouped["met"].min()),
-                "met_in_utc": met_to_utc(grouped["met"].min()).split(".")[0],
-                "ttj2000ns": int(met_to_ttj2000ns(grouped["met"].min())),
-                "swe_normalized_counts_half_1_esa": [int(val) for val in summed_first],
-                "swe_normalized_counts_half_2_esa": [int(val) for val in summed_second],
-                "swe_counterstreaming_electrons": max(bde_first_half, bde_second_half),
-            }
+                "met": met_second_half,
+                "met_in_utc": met_to_utc(met_second_half).split(".")[0],
+                "ttj2000ns": int(met_to_ttj2000ns(met_second_half)),
+                "swe_normalized_counts": [int(val) for val in summed_second],
+                "swe_counterstreaming_electrons": bde_second_half,
+            },
         )
 
     return swe_data

imap_processing/ialirt/utils/constants.py

@@ -2,19 +2,19 @@
 
 IALIRT_KEYS = [
     # H intensities in 15 energy ranges and binned into 4 azimuths and 4 spin angle bins
-    "codicehi_h",
+    "codice_hi_h",
     # C/O abundance ratio
-    "codicelo_c_over_o_abundance",
+    "codice_lo_c_over_o_abundance",
     # Mg/O abundance ratio
-    "codicelo_mg_over_o_abundance",
+    "codice_lo_mg_over_o_abundance",
     # Fe/O abundance ratio
-    "codicelo_fe_over_o_abundance",
+    "codice_lo_fe_over_o_abundance",
     # C+6/C+5 charge state ratio
-    "codicelo_c_plus_6_over_c_plus_5_ratio",
+    "codice_lo_c_plus_6_over_c_plus_5_ratio",
     # O+7/O+6 charge state ratio
-    "codicelo_o_plus_7_over_o_plus_6_ratio",
+    "codice_lo_o_plus_7_over_o_plus_6_ratio",
     # Fe low/Fe high charge state ratio
-    "codicelo_fe_low_over_fe_high_ratio",
+    "codice_lo_fe_low_over_fe_high_ratio",
     # Low energy (~300 keV) electrons (A-side)
     "hit_e_a_side_low_en",
     # Medium energy (~3 MeV) electrons (A-side)
@@ -37,26 +37,32 @@ IALIRT_KEYS = [
     "hit_he_omni_low_en",
     # High energy (15 to 70 MeV/nuc) He (Omnidirectional)
     "hit_he_omni_high_en",
+    # MAG instrument epoch
+    "mag_epoch",
     # Magnetic field vector in GSE coordinates
-    "mag_4s_b_gse",
+    "mag_B_GSE",
     # Magnetic field vector in GSM coordinates
-    "mag_4s_b_gsm",
+    "mag_B_GSM",
     # Magnetic field vector in RTN coordinates
-    "mag_4s_b_rtn",
+    "mag_B_RTN",
+    # Magnitude of the magnetic field vector
+    "mag_B_magnitude",
     # Azimuth angle (φ) of the magnetic field in GSM coordinates
-    "mag_phi_4s_b_gsm",
+    "mag_phi_B_GSM",
     # Elevation angle (θ) of the magnetic field in GSM coordinates
-    "mag_theta_4s_b_gsm",
+    "mag_theta_B_GSM",
+    # Azimuth angle (φ) of the magnetic field in GSE coordinates
+    "mag_phi_B_GSE",
+    # Elevation angle (θ) of the magnetic field in GSE coordinates
+    "mag_theta_B_GSE",
     # Pseudo density of solar wind protons
     "swapi_pseudo_proton_density",
     # Pseudo speed of solar wind protons in solar inertial frame
     "swapi_pseudo_proton_speed",
     # Pseudo temperature of solar wind protons in plasma frame
     "swapi_pseudo_proton_temperature",
-    # SWE Normalized Counts - Half Cycle 1
-    "swe_normalized_counts_half_1",
-    # SWE Normalized Counts - Half Cycle 2
-    "swe_normalized_counts_half_2",
+    # SWE Normalized Counts
+    "swe_normalized_counts",
     # SWE Counterstreaming flag
     "swe_counterstreaming_electrons",
 ]

imap_processing/ialirt/utils/create_xarray.py

@@ -48,6 +48,13 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         attrs=cdf_manager.get_variable_attributes("component", check_schema=False),
     )
 
+    rtn_component = xr.DataArray(
+        ["radial", "tangential", "normal"],
+        name="RTN_component",
+        dims=["RTN_component"],
+        attrs=cdf_manager.get_variable_attributes("RTN_componentt", check_schema=False),
+    )
+
     esa_step = xr.DataArray(
         data=np.arange(8, dtype=np.uint8),
         name="esa_step",
@@ -57,32 +64,39 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
 
     energy_ranges = xr.DataArray(
         data=np.arange(15, dtype=np.uint8),
-        name="energy_ranges",
-        dims=["energy_ranges"],
-        attrs=cdf_manager.get_variable_attributes("energy_ranges", check_schema=False),
+        name="codice_hi_h_energy_ranges",
+        dims=["codice_hi_h_energy_ranges"],
+        attrs=cdf_manager.get_variable_attributes(
+            "codice_hi_h_energy_ranges", check_schema=False
+        ),
     )
 
-    azimuth = xr.DataArray(
+    elevation = xr.DataArray(
         data=np.arange(4, dtype=np.uint8),
-        name="azimuth",
-        dims=["azimuth"],
-        attrs=cdf_manager.get_variable_attributes("azimuth", check_schema=False),
+        name="codice_hi_h_elevation",
+        dims=["codice_hi_h_elevation"],
+        attrs=cdf_manager.get_variable_attributes(
+            "codice_hi_h_elevation", check_schema=False
+        ),
     )
 
-    spin_angle_bin = xr.DataArray(
+    spin_angle = xr.DataArray(
         data=np.arange(4, dtype=np.uint8),
-        name="spin_angle_bin",
-        dims=["spin_angle_bin"],
-        attrs=cdf_manager.get_variable_attributes("spin_angle_bin", check_schema=False),
+        name="codice_hi_h_spin_angle",
+        dims=["codice_hi_h_spin_angle"],
+        attrs=cdf_manager.get_variable_attributes(
+            "codice_hi_h_spin_anglen", check_schema=False
+        ),
     )
 
     coords = {
         "epoch": epoch,
         "component": component,
+        "RTN_component": rtn_component,
         "esa_step": esa_step,
-        "energy_ranges": energy_ranges,
-        "azimuth": azimuth,
-        "spin_angle_bin": spin_angle_bin,
+        "codice_hi_h_energy_ranges": energy_ranges,
+        "codice_hi_h_elevation": elevation,
+        "codice_hi_h_spin_angle": spin_angle,
     }
     dataset = xr.Dataset(
         coords=coords,
@@ -93,13 +107,22 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
     for key in instrument_keys:
         attrs = cdf_manager.get_variable_attributes(key, check_schema=False)
         fillval = attrs.get("FILLVAL")
-        if key.startswith("mag"):
+        if key in ["mag_B_GSE", "mag_B_GSM"]:
             data = np.full((n, 3), fillval, dtype=np.float32)
             dims = ["epoch", "component"]
             dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
-        elif key.startswith("codicehi"):
+        elif key == "mag_B_RTN":
+            data = np.full((n, 3), fillval, dtype=np.float32)
+            dims = ["epoch", "RTN_component"]
+            dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
+        elif key.startswith("codice_hi"):
             data = np.full((n, 15, 4, 4), fillval, dtype=np.float32)
-            dims = ["epoch", "energy", "azimuth", "spin_angle_bin"]
+            dims = [
+                "epoch",
+                "codice_hi_h_energy_ranges",
+                "codice_hi_h_elevation",
+                "codice_hi_h_spin_angle",
+            ]
             dataset[key] = xr.DataArray(data, dims=dims, attrs=attrs)
         elif key == "swe_counterstreaming_electrons":
             data = np.full(n, fillval, dtype=np.uint8)
@@ -123,11 +146,11 @@ def create_xarray_from_records(records: list[dict]) -> xr.Dataset:  # noqa: PLR0
         for key, val in record.items():
             if key in ["apid", "met", "met_in_utc", "ttj2000ns"]:
                 continue
-            elif key.startswith("mag"):
+            elif key in ["mag_B_GSE", "mag_B_GSM", "mag_B_RTN"]:
                 dataset[key].data[i, :] = val
             elif key.startswith("swe_normalized_counts"):
                 dataset[key].data[i, :] = val
-            elif key.startswith("codicehi"):
+            elif key.startswith("codice_hi"):
                 dataset[key].data[i, :, :, :] = val
             else:
                 dataset[key].data[i] = val

imap_processing/idex/idex_constants.py

@@ -46,6 +46,13 @@ NS_TO_S = 1e-9
 # Microseconds to seconds conversion
 US_TO_S = 1e-6
 
+# Seconds in a day
+SECONDS_IN_DAY = 86400
+# Nanoseconds in day
+NANOSECONDS_IN_DAY = SECONDS_IN_DAY * int(1e9)
+# fg to kg conversion factor
+FG_TO_KG = 1e-15
+
 TARGET_HIGH_FREQUENCY_CUTOFF = 100
 
 TARGET_NOISE_FREQUENCY = 7000
@@ -75,13 +82,9 @@ SPICE_ARRAYS = [
     "spin_phase",
 ]
 
-# Default IDEX Healpix parameters
-# Used in IDEX l2c processing
-IDEX_HEALPIX_NSIDE = 8
-IDEX_HEALPIX_NESTED = False
 # Default IDEX Rectangular parameters
 # Used in IDEX l2c processing
-IDEX_SPACING_DEG = 4  # TODO
+IDEX_SPACING_DEG = 6
 
 # Define the pointing reference frame for IDEX
 IDEX_EVENT_REFERENCE_FRAME = SpiceFrame.ECLIPJ2000