Using Masked inside Time

astropy/io/fits/fitstime.py

@@ -595,9 +595,11 @@ def time_to_fits(table):
 
         # The following is necessary to deal with multi-dimensional ``Time`` objects
         # (i.e. where Time.shape is non-trivial).
-        jd12 = np.stack([col.jd1, col.jd2], axis=-1)
-        # Roll the 0th (innermost) axis backwards, until it lies in the last position
-        # (jd12.ndim)
+        # Note: easier would be np.stack([col.jd1, col.jd2], axis=-1), but that
+        # fails for np.ma.MaskedArray, as it returns just the data, ignoring the mask.
+        jd12 = np.empty_like(col.jd1, shape=col.jd1.shape + (2,))
+        jd12[..., 0] = col.jd1
+        jd12[..., 1] = col.jd2
         newtable.replace_column(col.info.name, col_cls(jd12, unit="d"))
 
         # Time column-specific override keywords

astropy/io/fits/tests/test_fitstime.py

@@ -15,6 +15,7 @@
 from astropy.time.core import BARYCENTRIC_SCALES
 from astropy.time.formats import FITS_DEPRECATED_SCALES
 from astropy.utils.exceptions import AstropyUserWarning
+from astropy.utils.masked import Masked
 
 from .conftest import FitsTestCase
 
@@ -159,15 +160,16 @@ def test_time_to_fits_loc(self, table_types):
 
         assert tm["a"].location == t["a"].location
 
+    @pytest.mark.parametrize("masked_cls", (np.ma.MaskedArray, Masked))
     @pytest.mark.parametrize("mask", (False, [True, False]))
     @pytest.mark.parametrize("serialize_method", ("jd1_jd2", "formatted_value"))
-    def test_time_to_fits_serialize_method(self, serialize_method, mask):
+    def test_time_to_fits_serialize_method(self, serialize_method, mask, masked_cls):
         """
         Test the data returned by ``time_to_fits`` for masked values.
         """
-        a = Time(np.ma.MaskedArray(self.time, mask=mask))
+        a = Time(masked_cls(self.time, mask=mask))
         b = Time(
-            np.ma.MaskedArray([[1, 2], [3, 4]], mask=np.broadcast_to(mask, (2, 2))),
+            masked_cls([[1, 2], [3, 4]], mask=np.broadcast_to(mask, (2, 2))),
             format="cxcsec",
         )
         assert b.masked is a.masked is (mask is not False)

astropy/time/__init__.py

@@ -4,7 +4,7 @@
 
 class Conf(_config.ConfigNamespace):
     """
-    Configuration parameters for `astropy.table`.
+    Configuration parameters for `astropy.time`.
     """
 
     use_fast_parser = _config.ConfigItem(
@@ -16,6 +16,30 @@ class Conf(_config.ConfigNamespace):
         "options are all strings.",
     )
 
+    masked_array_type = _config.ConfigItem(
+        ["astropy", "numpy"],
+        'The type of masked array used for masked output data.  Can be "astropy" '
+        'for `astropy.utils.masked.Masked` or "numpy" to use `numpy.ma.MaskedArray`. '
+        "Note that if `astropy.units.Quantity` is produced, the output always "
+        "uses `astropy.utils.masked.Masked`, since `numpy.ma.MaskedArray` does not "
+        "work with quantities.",
+    )
+    # Create a dict of available masked classes for speed.
+    # Use local imports so we do not pollute the module namespace.
+    from numpy.ma import MaskedArray
+
+    from astropy.utils.masked import Masked
+
+    _MASKED_CLASSES = {"astropy": Masked, "numpy": MaskedArray}
+
+    @property
+    def _masked_cls(self):
+        """The masked class set by ``masked_array_type``.
+
+        This is |Masked| for "astropy", `numpy.ma.MaskedArray` for "numpy".
+        """
+        return self._MASKED_CLASSES[self.masked_array_type]
+
 
 conf = Conf()