SWAPI: fill ESA step 0 with nan value. Update acquisition time (IMAP-Science-Operations-Center#2102)

Author: tech3371

imap_processing/ialirt/l0/process_swapi.py

@@ -15,7 +15,7 @@
 from imap_processing.ialirt.utils.time import calculate_time
 from imap_processing.spice.time import met_to_ttj2000ns, met_to_utc
 from imap_processing.swapi.l1.swapi_l1 import process_sweep_data
-from imap_processing.swapi.l2.swapi_l2 import TIME_PER_BIN
+from imap_processing.swapi.l2.swapi_l2 import SWAPI_LIVETIME
 
 logger = logging.getLogger(__name__)
 
@@ -190,8 +190,8 @@ def process_swapi_ialirt(unpacked_data: xr.Dataset) -> list[dict]:
             continue
 
     raw_coin_count = process_sweep_data(grouped_dataset, "swapi_coin_cnt")
-    raw_coin_rate = raw_coin_count / TIME_PER_BIN
-    count_rate_error = np.sqrt(raw_coin_count) / TIME_PER_BIN
+    raw_coin_rate = raw_coin_count / SWAPI_LIVETIME
+    count_rate_error = np.sqrt(raw_coin_count) / SWAPI_LIVETIME
 
     solution = optimize_pseudo_parameters(raw_coin_rate, count_rate_error)
 

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"),
     )

imap_processing/swapi/l2/swapi_l2.py

@@ -12,7 +12,7 @@
 logger = logging.getLogger(__name__)
 
 
-TIME_PER_BIN = 0.167  # seconds
+SWAPI_LIVETIME = 0.145  # seconds
 
 
 def solve_full_sweep_energy(
@@ -159,14 +159,12 @@ def swapi_l2(
 
     To process science data to L2, we need to:
     - convert counts to rates. This is done by dividing the counts by the
-        TIME_PER_BIN time. TIME_PER_BIN is the exposure time per energy bin which is
-        obtained by dividing the time for one complete sweep
-        (12 s, coarse + fine sweep) by the total energy steps (72),
-        i.e., TIME_PER_BIN = 12/72 = 0.167 s. This will be constant.
+        SWAPI_LIVETIME time. LIVETIME is data acquisition time. It will
+        be constant, SWAPI_LIVETIME = 0.145 s.
 
     - update uncertainty. Calculate new uncertainty value using
-        SWP_PCEM_ERR data from level one and divide by TIME_PER_BIN. Eg.
-            SWP_PCEM_UNC = SWP_PCEM_ERR / TIME_PER_BIN
+        SWP_PCEM_ERR data from level one and divide by SWAPI_LIVETIME. Eg.
+            SWP_PCEM_UNC = SWP_PCEM_ERR / SWAPI_LIVETIME
         Do the same for SCEM and COIN data.
 
     Parameters
@@ -233,32 +231,32 @@ def swapi_l2(
     ]
 
     # convert counts to rate
-    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / TIME_PER_BIN
-    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / TIME_PER_BIN
+    l2_dataset["swp_pcem_rate"] = l1_dataset["swp_pcem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_scem_rate"] = l1_dataset["swp_scem_counts"] / SWAPI_LIVETIME
+    l2_dataset["swp_coin_rate"] = l1_dataset["swp_coin_counts"] / SWAPI_LIVETIME
     # update attrs
     l2_dataset["swp_pcem_rate"].attrs = cdf_manager.get_variable_attributes("pcem_rate")
     l2_dataset["swp_scem_rate"].attrs = cdf_manager.get_variable_attributes("scem_rate")
     l2_dataset["swp_coin_rate"].attrs = cdf_manager.get_variable_attributes("coin_rate")
 
     # update uncertainty
     l2_dataset["swp_pcem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_pcem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_pcem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_scem_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_scem_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_scem_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_plus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_plus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_plus"] / SWAPI_LIVETIME
     )
     l2_dataset["swp_coin_rate_stat_uncert_minus"] = (
-        l1_dataset["swp_coin_counts_stat_uncert_minus"] / TIME_PER_BIN
+        l1_dataset["swp_coin_counts_stat_uncert_minus"] / SWAPI_LIVETIME
     )
     # update attrs
     l2_dataset[

imap_processing/tests/swapi/test_swapi_l1.py

@@ -84,7 +84,7 @@ def test_decompress_count():
     # compressed + no-overflow, compressed + overflow, no compression
     raw_values = np.array([[12, 0xFFFF, 12]])
     compression_flag = np.array([[1, 1, 0]])
-    expected = np.array([[12 * 16, np.iinfo(np.int32).max, 12]], dtype=np.int32)
+    expected = np.array([[12 * 16, np.iinfo(np.int32).max, 12]], dtype=np.float32)
     returned_value = decompress_count(raw_values, compression_flag)
     np.testing.assert_array_equal(returned_value, expected)
 

imap_processing/tests/swapi/test_swapi_l2.py

@@ -10,7 +10,7 @@
 from imap_processing.cdf.utils import load_cdf, write_cdf
 from imap_processing.swapi.l1.swapi_l1 import swapi_l1
 from imap_processing.swapi.l2.swapi_l2 import (
-    TIME_PER_BIN,
+    SWAPI_LIVETIME,
     solve_full_sweep_energy,
     swapi_l2,
 )
@@ -123,7 +123,7 @@ def second_get_file_paths_side_effect(descriptor):
     # Test uncertainty variables are as expected
     np.testing.assert_array_equal(
         l2_dataset["swp_pcem_rate_stat_uncert_plus"],
-        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / TIME_PER_BIN,
+        l1_dataset["swp_pcem_counts_stat_uncert_plus"] / SWAPI_LIVETIME,
     )
     # Since L2 data's date is before any date in ESA unit conversion table,
     # check that it returns nan in first 63 energy steps