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

imap_processing/tests/ena_maps/test_ena_maps.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
+import json
+import tempfile
 from copy import deepcopy
+from pathlib import Path
 from unittest import mock
 
 import astropy_healpix.healpy as hp
@@ -10,6 +13,7 @@ import numpy as np
 import pytest
 import xarray as xr
 
+from imap_processing.cdf.utils import load_cdf, write_cdf
 from imap_processing.ena_maps import ena_maps
 from imap_processing.ena_maps.utils import spatial_utils
 from imap_processing.ena_maps.utils.coordinates import CoordNames
@@ -52,8 +56,8 @@ class TestUltraPointingSet:
         """Test instantiation of UltraPointingSet"""
         ultra_psets = [
             ena_maps.UltraPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.l1c_pset_products
         ]
@@ -78,15 +82,40 @@ class TestUltraPointingSet:
             # Check that the unwrapped_dims_dict is as expected
             assert ultra_pset.unwrapped_dims_dict["counts"] == (
                 "epoch",
-                "energy",
+                "energy_bin_geometric_mean",
                 "pixel",
             )
             # Check the non_spatial_coords are as expected
             assert tuple(ultra_pset.non_spatial_coords.keys()) == (
                 "epoch",
-                "energy",
+                "energy_bin_geometric_mean",
             )
 
+    @pytest.mark.usefixtures("_setup_ultra_l1c_pset_products")
+    def test_init_cdf(
+        self,
+    ):
+        ultra_pset = self.l1c_pset_products[0]
+
+        cdf_filepath = write_cdf(ultra_pset, istp=False)
+
+        ultra_pset_from_dataset = ena_maps.UltraPointingSet(ultra_pset)
+
+        ultra_pset_from_str = ena_maps.UltraPointingSet(cdf_filepath)
+        ultra_pset_from_path = ena_maps.UltraPointingSet(Path(cdf_filepath))
+
+        np.testing.assert_allclose(
+            ultra_pset_from_dataset.data["counts"].values,
+            ultra_pset_from_str.data["counts"].values,
+            rtol=1e-6,
+        )
+
+        np.testing.assert_allclose(
+            ultra_pset_from_dataset.data["counts"].values,
+            ultra_pset_from_path.data["counts"].values,
+            rtol=1e-6,
+        )
+
     @pytest.mark.usefixtures("_setup_ultra_l1c_pset_products")
     @pytest.mark.usefixtures("_setup_ultra_l1c_pset_products")
     def test_different_spacing_raises_error(self):
@@ -100,11 +129,44 @@ class TestUltraPointingSet:
 
         with pytest.raises(ValueError, match="do not match"):
             ena_maps.UltraPointingSet(
+                ultra_pset_ds,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=ultra_pset_ds,
             )
 
 
+@pytest.fixture(scope="module")
+def hi_pset_cdf_path(imap_tests_path):
+    return imap_tests_path / "hi/data/l1/imap_hi_l1c_45sensor-pset_20250415_v999.cdf"
+
+
+@pytest.mark.external_test_data
+class TestHiPointingSet:
+    """Test suite for HiPointingSet class."""
+
+    def test_init(self, hi_pset_cdf_path):
+        """Test coverage for __init__ method."""
+        pset_ds = load_cdf(hi_pset_cdf_path)
+        hi_pset = ena_maps.HiPointingSet(pset_ds)
+        assert isinstance(hi_pset, ena_maps.HiPointingSet)
+        assert hi_pset.spice_reference_frame == geometry.SpiceFrame.ECLIPJ2000
+        assert hi_pset.num_points == 3600
+        np.testing.assert_array_equal(hi_pset.az_el_points.shape, (3600, 2))
+
+    def test_from_cdf(self, hi_pset_cdf_path):
+        """Test coverage for from_cdf method."""
+        hi_pset = ena_maps.HiPointingSet(hi_pset_cdf_path)
+        assert isinstance(hi_pset, ena_maps.HiPointingSet)
+
+    def test_plays_nice_with_rectangular_sky_map(self, hi_pset_cdf_path):
+        """Test that HiPointingSet works with RectangularSkyMap"""
+        hi_pset = ena_maps.HiPointingSet(hi_pset_cdf_path)
+        rect_map = ena_maps.RectangularSkyMap(
+            spacing_deg=2, spice_frame=geometry.SpiceFrame.ECLIPJ2000
+        )
+        rect_map.project_pset_values_to_map(hi_pset, ["counts", "exposure_times"])
+        assert rect_map.data_1d["counts"].max() > 0
+
+
 class TestRectangularSkyMap:
     @pytest.fixture(autouse=True)
     def _setup_ultra_l1c_pset_products(self, setup_all_pset_products):
@@ -115,8 +177,8 @@ class TestRectangularSkyMap:
         )
         self.ultra_psets = [
             ena_maps.UltraPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.ultra_l1c_pset_products
         ]
@@ -130,8 +192,8 @@ class TestRectangularSkyMap:
         )
         self.rectangular_psets = [
             ena_maps.RectangularPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.rectangular_l1c_pset_products
         ]
@@ -188,7 +250,7 @@ class TestRectangularSkyMap:
         for ultra_pset in self.ultra_psets:
             rectangular_map.project_pset_values_to_map(
                 ultra_pset,
-                value_keys=["counts", "exposure_time"],
+                value_keys=["counts", "exposure_factor"],
                 index_match_method=index_matching_method,
             )
 
@@ -199,20 +261,22 @@ class TestRectangularSkyMap:
         simple_summed_pset_counts_by_energy = np.zeros(
             shape=(
                 self.ultra_l1c_pset_products[0]["counts"].sizes[
-                    CoordNames.ENERGY.value
+                    CoordNames.ENERGY_ULTRA.value
                 ],
             )
         )
         for pset in self.ultra_l1c_pset_products:
             simple_summed_pset_counts_by_energy += pset["counts"].sum(
-                dim=[d for d in pset["counts"].dims if d != CoordNames.ENERGY.value]
+                dim=[
+                    d for d in pset["counts"].dims if d != CoordNames.ENERGY_ULTRA.value
+                ]
             )
 
         rmap_counts_per_energy_bin = rectangular_map.data_1d["counts"].sum(
             dim=[
                 d
                 for d in rectangular_map.data_1d["counts"].dims
-                if d != CoordNames.ENERGY.value
+                if d != CoordNames.ENERGY_ULTRA.value
             ]
         )
 
@@ -235,7 +299,7 @@ class TestRectangularSkyMap:
         """
         index_matching_method = ena_maps.IndexMatchMethod.PUSH
 
-        pset_spacing_deg = self.rectangular_psets[0].spacing_deg
+        pset_spacing_deg = self.rectangular_psets[0].sky_grid.spacing_deg
 
         # Mock frame_transform to return the az and el unchanged
         mock_frame_transform_az_el.side_effect = (
@@ -251,7 +315,7 @@ class TestRectangularSkyMap:
         for rectangular_pset in self.rectangular_psets:
             rectangular_map.project_pset_values_to_map(
                 rectangular_pset,
-                value_keys=["counts", "exposure_time"],
+                value_keys=["counts", "exposure_factor"],
                 index_match_method=index_matching_method,
             )
 
@@ -262,20 +326,22 @@ class TestRectangularSkyMap:
         simple_summed_pset_counts_by_energy = np.zeros(
             shape=(
                 self.rectangular_l1c_pset_products[0]["counts"].sizes[
-                    CoordNames.ENERGY.value
+                    CoordNames.ENERGY_ULTRA.value
                 ],
             )
         )
         for pset in self.rectangular_l1c_pset_products:
             simple_summed_pset_counts_by_energy += pset["counts"].sum(
-                dim=[d for d in pset["counts"].dims if d != CoordNames.ENERGY.value]
+                dim=[
+                    d for d in pset["counts"].dims if d != CoordNames.ENERGY_ULTRA.value
+                ]
             )
 
         rmap_counts_per_energy_bin = rectangular_map.data_1d["counts"].sum(
             dim=[
                 d
                 for d in rectangular_map.data_1d["counts"].dims
-                if d != CoordNames.ENERGY.value
+                if d != CoordNames.ENERGY_ULTRA.value
             ]
         )
 
@@ -344,7 +410,7 @@ class TestRectangularSkyMap:
 
             rectangular_map.project_pset_values_to_map(
                 rectangular_pset,
-                value_keys=["counts", "exposure_time"],
+                value_keys=["counts", "exposure_factor"],
                 index_match_method=index_matching_method,
             )
             expected_value_every_pixel += pset_num
@@ -372,13 +438,13 @@ class TestRectangularSkyMap:
         assert "counts" in rect_map_ds.data_vars
         assert rect_map_ds["counts"].shape == (
             1,
-            rectangular_pset.data["counts"].sizes[CoordNames.ENERGY.value],
+            rectangular_pset.data["counts"].sizes[CoordNames.ENERGY_ULTRA.value],
             360 / skymap_spacing,
             180 / skymap_spacing,
         )
         assert rect_map_ds["counts"].dims == (
             CoordNames.TIME.value,
-            CoordNames.ENERGY.value,
+            CoordNames.ENERGY_ULTRA.value,
             CoordNames.AZIMUTH_L2.value,
             CoordNames.ELEVATION_L2.value,
         )
@@ -403,8 +469,8 @@ class TestHealpixSkyMap:
         )
         self.ultra_psets = [
             ena_maps.UltraPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.ultra_l1c_pset_products
         ]
@@ -418,8 +484,8 @@ class TestHealpixSkyMap:
         )
         self.rectangular_psets = [
             ena_maps.RectangularPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.rectangular_l1c_pset_products
         ]
@@ -491,7 +557,7 @@ class TestHealpixSkyMap:
 
         # Create a PointingSet with a bright spot
         mock_pset_input_frame = ena_maps.UltraPointingSet(
-            l1c_dataset=self.ultra_l1c_pset_products[0],
+            self.ultra_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
         mock_pset_input_frame.data["counts"].values = np.zeros_like(
@@ -534,7 +600,7 @@ class TestHealpixSkyMap:
         assert "counts" in hp_map.data_1d.data_vars
 
         # Find the maximum value in the spatial pixel dimension of the healpix map
-        bright_hp_pixel_index = hp_map.data_1d["counts"][0, :].argmax()
+        bright_hp_pixel_index = hp_map.data_1d["counts"][0, :].values.argmax()
         bright_hp_pixel_az_el = hp_map.az_el_points[bright_hp_pixel_index]
 
         np.testing.assert_allclose(
@@ -573,7 +639,7 @@ class TestHealpixSkyMap:
 
         # Create a PointingSet with a bright spot
         mock_pset_input_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[0],
+            self.rectangular_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
         mock_pset_input_frame.data["counts"].values = np.zeros_like(
@@ -584,10 +650,13 @@ class TestHealpixSkyMap:
         mock_pset_input_frame.data["counts"].values[
             :,
             :,
-            int(input_bright_pixel_az_el_deg[0] // mock_pset_input_frame.spacing_deg),
+            int(
+                input_bright_pixel_az_el_deg[0]
+                // mock_pset_input_frame.sky_grid.spacing_deg
+            ),
             int(
                 (90 + input_bright_pixel_az_el_deg[1])
-                // mock_pset_input_frame.spacing_deg
+                // mock_pset_input_frame.sky_grid.spacing_deg
             ),
         ] = 1
 
@@ -625,12 +694,12 @@ class TestHealpixSkyMap:
         assert "counts" in hp_map_ds.data_vars
         assert hp_map_ds["counts"].shape == (
             1,
-            mock_pset_input_frame.data["counts"].sizes[CoordNames.ENERGY.value],
+            mock_pset_input_frame.data["counts"].sizes[CoordNames.ENERGY_ULTRA.value],
             hp_map.num_points,
         )
         assert hp_map_ds["counts"].dims == (
             CoordNames.TIME.value,
-            CoordNames.ENERGY.value,
+            CoordNames.ENERGY_ULTRA.value,
             CoordNames.HEALPIX_INDEX.value,
         )
         np.testing.assert_array_equal(
@@ -638,6 +707,221 @@ class TestHealpixSkyMap:
             hp_map.data_1d["counts"].values,
         )
 
+    @mock.patch("astropy_healpix.healpy.ang2pix")
+    def test_calculate_rect_pixel_value_from_healpix_map_n_subdivisions(
+        self,
+        mock_ang2pix,
+    ):
+        """Test getting rectangular pixel values from HealpixSkyMap via subdivision."""
+
+        # Mock ang2pix to return fixed values based on a dict
+        pixel_dict = {
+            # 0 subdiv - just 1 pixel
+            (180, 0): 0,
+            # 1 subdiv - all subpix have same solid angle because centered on equator
+            (179, -1): 1,
+            (179, 1): 2,
+            (181, -1): 3,
+            (181, 1): 4,
+            # 2 subdiv - 'Inner' subpix have larger solid angle than 'outer' subpix
+            (178.5, -1.5): 5,
+            (178.5, -0.5): 6,
+            (178.5, 0.5): 7,
+            (178.5, 1.5): 8,
+            (179.5, -1.5): 9,
+            (179.5, -0.5): 10,
+            (179.5, 0.5): 11,
+            (179.5, 1.5): 12,
+            (180.5, -1.5): 12,
+            (180.5, -0.5): 14,
+            (180.5, 0.5): 15,
+            (180.5, 1.5): 16,
+            (181.5, -1.5): 17,
+            (181.5, -0.5): 18,
+            (181.5, 0.5): 19,
+            (181.5, 1.5): 20,
+        }
+        expected_mean_0_subdivisions = 0
+        expected_mean_1_subdivisions = 2.5
+        expected_mean_2_subdivisions = 12.5
+
+        def mock_ang2pix_fn(nside, theta, phi, nest=True, lonlat=False):
+            vals = []
+            for pix_num in range(len(theta)):
+                key = (theta[pix_num], phi[pix_num])
+                vals.append(pixel_dict.get(key, 0))
+            return np.array(vals)
+
+        hp_map = ena_maps.HealpixSkyMap(
+            nside=16,
+            spice_frame=geometry.SpiceFrame.ECLIPJ2000,
+            nested=True,
+        )
+        hp_map.data_1d["counts"] = xr.DataArray(
+            data=[
+                np.arange(hp_map.num_points),
+            ],
+            dims=["epoch", "pixel"],
+        )
+
+        for num_subdiv, (expected_value, atol) in enumerate(
+            [
+                # The first subdivs have all the same solid angle
+                (expected_mean_0_subdivisions, 1e-9),
+                (expected_mean_1_subdivisions, 1e-9),
+                # Slight difference from not taking into account asym solid angle
+                (expected_mean_2_subdivisions, 0.1),
+            ]
+        ):
+            mock_ang2pix.reset_mock()
+            mock_ang2pix.side_effect = mock_ang2pix_fn
+            mean_value = (
+                hp_map.calculate_rect_pixel_value_from_healpix_map_n_subdivisions(
+                    rect_pix_center_lon_lat=(180, 0),
+                    rect_pix_spacing_deg=4,
+                    value_array=hp_map.data_1d["counts"],
+                    num_subdivisions=num_subdiv,
+                )
+            )
+            np.testing.assert_allclose(
+                mean_value,
+                expected_value,
+                atol=atol,
+                err_msg=f"Failed for num_subdivisions: {num_subdiv}",
+            )
+        hp_map.calculate_rect_pixel_value_from_healpix_map_n_subdivisions(
+            rect_pix_center_lon_lat=(180, 0),
+            rect_pix_spacing_deg=2,
+            value_array=hp_map.data_1d["counts"],
+            num_subdivisions=0,
+        )
+
+    @mock.patch(
+        "imap_processing.ena_maps.ena_maps.HealpixSkyMap.calculate_rect_pixel_value_from_healpix_map_n_subdivisions"
+    )
+    def test_get_rect_pixel_value_recursive_subdivs(
+        self,
+        mock_calculate_rect_pixel_value_from_healpix_map_n_subdivisions,
+    ):
+        """Test that the recursive subdivision works as expected with different rtol."""
+
+        # Mock the function to return a fixed value for a number of subdivisions
+        value_by_subdivisions = {
+            0: 100.0,
+            1: 110.0,  # 10/110 = 0.09090909 change
+            2: 105.0,  # 5/105 = 0.04761905 change
+            3: 107.0,  # 2/107 = 0.01869159 change
+            4: 107.5,  # 0.5/107.5 = 0.00465116 change
+            5: 107.51,  # 0.01/107.51 = 0.00009301 change
+            6: 107.5099,  # 0.0001/107.5099 = 0.00000093 change
+            7: 120,  # Big change - but will stop because of MAX SUBDIVS
+        }
+        required_rtols = [
+            0.1,
+            0.05,
+            0.02,
+            0.005,
+            0.0001,
+            0.000001,
+            1e-12,
+        ]
+
+        mock_calculate_rect_pixel_value_from_healpix_map_n_subdivisions.side_effect = (
+            lambda *args, **kwargs: np.array(
+                [
+                    value_by_subdivisions[kwargs["num_subdivisions"]],
+                ]
+            )
+        )
+        hp_map = ena_maps.HealpixSkyMap(
+            nside=16,
+            spice_frame=geometry.SpiceFrame.ECLIPJ2000,
+        )
+
+        # Test the recursive subdivision by setting different tolerances to get the
+        # expected number of subdivisions and resultant mean value.
+        for expected_subdiv_level in range(1, len(required_rtols)):
+            mean, depth = hp_map.get_rect_pixel_value_recursive_subdivs(
+                rect_pix_center_lon_lat=(180, 0),
+                rect_pix_spacing_deg=4,
+                value_array=[],
+                rtol=required_rtols[expected_subdiv_level - 1],
+                max_subdivision_depth=7,
+            )
+            assert depth == expected_subdiv_level
+            np.testing.assert_equal(
+                mean,
+                value_by_subdivisions[expected_subdiv_level],
+                err_msg=f"Failed for expected_subdiv_level: {expected_subdiv_level}",
+            )
+
+    def test_to_rectangular_skymap(
+        self,
+    ):
+        hp_map = ena_maps.HealpixSkyMap(
+            nside=64,
+            spice_frame=geometry.SpiceFrame.ECLIPJ2000,
+        )
+
+        hp_map.data_1d["counts"] = xr.DataArray(
+            data=np.fromfunction(
+                lambda time, energy, pixel: 1000 + pixel * (10 * (energy + 1)),
+                shape=(1, 10, hp_map.num_points),
+                dtype=np.float32,
+            ),
+            dims=["epoch", "energy", "pixel"],
+        )
+        hp_map.data_1d["exposure_factor"] = xr.DataArray(
+            data=np.ones((10, hp_map.num_points)),
+            dims=["energy", "pixel"],
+        )
+        hp_map.data_1d["observation_date"] = xr.DataArray(
+            data=np.ones(hp_map.num_points),
+            dims=["pixel"],
+        )
+
+        rect_map, subdiv_depth_dict = hp_map.to_rectangular_skymap(
+            rect_spacing_deg=2,
+            value_keys=["counts", "exposure_factor", "observation_date"],
+        )
+
+        for value_key, subdiv_depth in subdiv_depth_dict.items():
+            # subdiv depth should always be between 1 and
+            # ena_maps.MAX_SUBDIV_RECURSION_DEPTH
+            np.testing.assert_array_less(
+                0,
+                subdiv_depth,
+                err_msg=f"subdiv <1 for: {value_key}",
+            )
+            np.testing.assert_array_less(
+                subdiv_depth,
+                ena_maps.MAX_SUBDIV_RECURSION_DEPTH + 1,
+                err_msg=f"subdiv >MAX for: {value_key}",
+            )
+
+            # The min and max values of the rect and healpix maps should be close
+            # The min will have a larger relative tolerance because the variation
+            # in the test data is larger in comparison to the min value than to the max
+            np.testing.assert_allclose(
+                rect_map.data_1d[value_key].min(),
+                hp_map.data_1d[value_key].min(),
+                rtol=5e-2,
+                err_msg=f"Min values of {value_key} do not match",
+            )
+            np.testing.assert_allclose(
+                rect_map.data_1d[value_key].max(),
+                hp_map.data_1d[value_key].max(),
+                rtol=1e-3,
+                err_msg=f"Max values of {value_key} do not match",
+            )
+
+            # The dims of the rect map should be the same as the healpix map,
+            # except for the final pixel dimension
+            assert (
+                rect_map.data_1d[value_key].dims[:-1]
+                == hp_map.data_1d[value_key].dims[:-1]
+            )
+
 
 class TestIndexMatching:
     @pytest.fixture(autouse=True)
@@ -649,8 +933,8 @@ class TestIndexMatching:
         )
         self.rectangular_psets = [
             ena_maps.RectangularPointingSet(
+                l1c_product,
                 spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
-                l1c_dataset=l1c_product,
             )
             for l1c_product in self.rectangular_l1c_pset_products
         ]
@@ -670,7 +954,7 @@ class TestIndexMatching:
 
         # Mock a PSET, overriding the az/el points
         mock_pset_input_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[0],
+            self.rectangular_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
         manual_az_el_coords = np.array(
@@ -748,7 +1032,7 @@ class TestIndexMatching:
 
         # Make a PointingSet
         mock_pset_input_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[0],
+            self.rectangular_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
 
@@ -787,7 +1071,7 @@ class TestIndexMatching:
         self,
     ):
         mock_pset_input_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[0],
+            self.rectangular_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.ECLIPJ2000,
         )
         # Until implemented, just change the tiling on a RectangularSkyMap
@@ -803,11 +1087,11 @@ class TestIndexMatching:
 
     def test_match_coords_to_indices_pset_to_pset_error(self):
         mock_pset_input_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[0],
+            self.rectangular_l1c_pset_products[0],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
         mock_pset_output_frame = ena_maps.RectangularPointingSet(
-            l1c_dataset=self.rectangular_l1c_pset_products[1],
+            self.rectangular_l1c_pset_products[1],
             spice_reference_frame=geometry.SpiceFrame.IMAP_DPS,
         )
         with pytest.raises(
@@ -836,3 +1120,148 @@ class TestIndexMatching:
         _ = ena_maps.match_coords_to_indices(
             mock_rect_map_1, mock_rect_map_2, event_et=0
         )
+
+
+class TestAbstractSkyMap:
+    @pytest.mark.parametrize(
+        "skymap_props_dict",
+        [
+            pytest.param(
+                # HealpixSkyMap properties
+                {
+                    "sky_tiling_type": "HEALPIX",
+                    "nside": 32,
+                    "nested": True,
+                    "spice_reference_frame": geometry.SpiceFrame.ECLIPJ2000.name,
+                    "values_to_push_project": ["foo", "bar"],
+                },
+                id="healpix-skymap",
+            ),
+            pytest.param(
+                {
+                    "sky_tiling_type": "RECTANGULAR",
+                    "spacing_deg": 2,
+                    "spice_reference_frame": geometry.SpiceFrame.ECLIPJ2000.name,
+                    "values_to_pull_project": ["potato", "po-tah-to"],
+                },
+                id="rectangular-skymap",
+            ),
+        ],
+    )
+    def test_to_dict_and_from_dict(self, skymap_props_dict):
+        """Test serialization to and from dictionary"""
+        # Make a SkyMap from the original properties dict
+        skymap_from_dict = ena_maps.AbstractSkyMap.from_dict(skymap_props_dict)
+
+        # Use the SkyMap to create a new properties dict
+        dict_from_skymap = skymap_from_dict.to_dict()
+
+        assert (
+            skymap_from_dict.spice_reference_frame
+            == geometry.SpiceFrame[skymap_props_dict["spice_reference_frame"]]
+        )
+
+        if skymap_props_dict["sky_tiling_type"] == "HEALPIX":
+            assert isinstance(skymap_from_dict, ena_maps.HealpixSkyMap), (
+                "from_dict should return a HealpixSkyMap object"
+            )
+            assert skymap_from_dict.nside == skymap_props_dict["nside"]
+            assert skymap_from_dict.nested == skymap_props_dict["nested"]
+            assert (
+                skymap_from_dict.values_to_push_project
+                == skymap_props_dict["values_to_push_project"]
+            )
+            assert skymap_from_dict.values_to_pull_project == []
+
+        elif skymap_props_dict["sky_tiling_type"] == "RECTANGULAR":
+            assert isinstance(skymap_from_dict, ena_maps.RectangularSkyMap), (
+                "from_dict should return a RectangularSkyMap object"
+            )
+            assert skymap_from_dict.spacing_deg == skymap_props_dict["spacing_deg"]
+            assert skymap_from_dict.values_to_push_project == []
+            assert (
+                skymap_from_dict.values_to_pull_project
+                == skymap_props_dict["values_to_pull_project"]
+            )
+
+        for key in [
+            "sky_tiling_type",
+            "spice_reference_frame",
+            "nside",
+            "nested",
+            "spacing_deg",
+        ]:
+            if key in skymap_props_dict:
+                assert dict_from_skymap[key] == skymap_props_dict[key]
+
+        # Check that the dict from the SkyMap matches the original dict ONLY after
+        # adding automatically added "values_to_push_project"/"values_to_pull_project"
+        # key to the original dict
+        assert dict_from_skymap != skymap_props_dict
+
+        # In the dicts passed in above, the HEALPIX one is missing the pull key
+        # and the RECTANGULAR one is missing the push key
+        if skymap_props_dict["sky_tiling_type"] == "HEALPIX":
+            skymap_props_dict["values_to_pull_project"] = []
+        elif skymap_props_dict["sky_tiling_type"] == "RECTANGULAR":
+            skymap_props_dict["values_to_push_project"] = []
+        assert dict_from_skymap == skymap_props_dict
+
+        # Change a value in the new dict and check that it is not equal to the original
+        dict_from_skymap["spice_reference_frame"] = "SPACE!"
+        assert (
+            dict_from_skymap["spice_reference_frame"]
+            != skymap_props_dict["spice_reference_frame"]
+        )
+
+    def test_to_json_and_from_json(self):
+        """Test serialization to and from JSON"""
+        # Make a SkyMap from the original properties dict
+        skymap_props_dict = {
+            "sky_tiling_type": "HEALPIX",
+            "nside": 32,
+            "nested": True,
+            "spice_reference_frame": geometry.SpiceFrame.ECLIPJ2000.name,
+            "values_to_push_project": ["foo", "bar"],
+        }
+
+        # Write a temporary json file with the properties dict
+
+        with tempfile.NamedTemporaryFile(
+            delete=False, suffix=".json", mode="w"
+        ) as temp_file:
+            json.dump(skymap_props_dict, temp_file)
+            temp_file_path_input = temp_file.name
+
+        # Read the json file and create a new SkyMap from it
+        skymap_from_json = ena_maps.AbstractSkyMap.from_json(temp_file_path_input)
+
+        # Create json output from the SkyMap at a separate temporary file path
+        temp_file_path_output = tempfile.NamedTemporaryFile(
+            delete=False, suffix=".json", mode="w"
+        ).name
+        skymap_from_json.to_json(json_path=temp_file_path_output)
+
+        assert skymap_from_json.spice_reference_frame == geometry.SpiceFrame.ECLIPJ2000
+        assert skymap_from_json.tiling_type is ena_maps.SkyTilingType.HEALPIX
+        assert skymap_from_json.nside == 32
+        assert skymap_from_json.nested is True
+        assert skymap_from_json.values_to_push_project == ["foo", "bar"]
+        assert skymap_from_json.values_to_pull_project == []
+
+        # Expect there to be a AttributeError when accessing a non-existent key
+        with pytest.raises(AttributeError):
+            _ = skymap_from_json.spacing_deg
+
+        # Check that the json output is the same as the original input ONLY
+        # after adding automatically added
+        # "values_to_push_project"/"values_to_pull_project" key to the original dict
+        with open(temp_file_path_input) as f:
+            original_json = json.load(f)
+        with open(temp_file_path_output) as f:
+            output_json = json.load(f)
+        # The output json will have added an empty list for values_to_pull_project
+        assert original_json != output_json
+        # add the values_to_pull_project key to the original json
+        original_json["values_to_pull_project"] = []
+        assert original_json == output_json