PIPE2D-1000: Revert all arrays except wavelengths from double to single precision float

python/pfs/datamodel/fluxTable.py

@@ -69,8 +69,8 @@ def toFits(self, fits):
         header['DAMD_VER'] = (1, "FluxTable datamodel version")
         hdu = BinTableHDU.from_columns([
             Column("wavelength", "D", array=self.wavelength),
-            Column("flux", "D", array=self.flux),
-            Column("error", "D", array=self.error),
+            Column("flux", "E", array=self.flux),
+            Column("error", "E", array=self.error),
             Column("mask", "K", array=self.mask),
         ], header=header, name=self._hduName)
         fits.append(hdu)
@@ -92,6 +92,6 @@ def fromFits(cls, fits):
         hdu = fits[cls._hduName]
         header = astropyHeaderToDict(hdu.header)
         flags = MaskHelper.fromFitsHeader(header)
-        return cls(hdu.data["wavelength"].astype(float), hdu.data["flux"].astype(float),
-                   hdu.data["error"].astype(float), hdu.data["mask"].astype(np.int32),
+        return cls(hdu.data["wavelength"].astype(float), hdu.data["flux"].astype(np.float32),
+                   hdu.data["error"].astype(np.float32), hdu.data["mask"].astype(np.int32),
                    flags)

python/pfs/datamodel/pfsFiberArray.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from .pfsSimpleSpectrum import PfsSimpleSpectrum
 from .utils import wraparoundNVisit, inheritDocstrings
 from .fluxTable import FluxTable
@@ -88,10 +90,10 @@ def _readImpl(cls, fits):
             Keyword arguments for constructing spectrum.
         """
         data = super()._readImpl(fits)
-        data["sky"] = fits["SKY"].data.astype(float)
+        data["sky"] = fits["SKY"].data.astype(np.float32)
         data["observations"] = Observations.fromFits(fits)
-        data["covar"] = fits["COVAR"].data.astype(float)
-        data["covar2"] = fits["COVAR2"].data.astype(float)
+        data["covar"] = fits["COVAR"].data.astype(np.float32)
+        data["covar2"] = fits["COVAR2"].data.astype(np.float32)
         try:
             fluxTable = FluxTable.fromFits(fits)
         except KeyError as exc:
@@ -118,9 +120,9 @@ def _writeImpl(self, fits):
         from astropy.io.fits import ImageHDU
         header = super()._writeImpl(fits)
         header["DAMD_VER"] = (1, "PfsFiberArray datamodel version")
-        fits.append(ImageHDU(self.sky, header=header, name="SKY"))
-        fits.append(ImageHDU(self.covar, header=header, name="COVAR"))
-        fits.append(ImageHDU(self.covar2, name="COVAR2"))
+        fits.append(ImageHDU(self.sky.astype(np.float32), header=header, name="SKY"))
+        fits.append(ImageHDU(self.covar.astype(np.float32), header=header, name="COVAR"))
+        fits.append(ImageHDU(self.covar2.astype(np.float32), name="COVAR2"))
         self.observations.toFits(fits)
         if self.fluxTable is not None:
             self.fluxTable.toFits(fits)

python/pfs/datamodel/pfsFiberArraySet.py

@@ -220,19 +220,19 @@ def readFits(cls, filename):
             data["metadata"] = astropyHeaderToDict(fd[0].header)
             for attr, dtype in (("fiberId", np.int32),
                                 ("wavelength", float),
-                                ("flux", float),
-                                ("mask", np.int32),
-                                ("sky", float),
+                                ("flux", np.float32),
+                                ("mask", np.uint32),
+                                ("sky", np.float32),
                                 # "norm" is treated separately, for backwards-compatibility
                                 ("covar", float)
                                 ):
                 hduName = attr.upper()
                 data[attr] = fd[hduName].data.astype(dtype)
             version = fd[0].header["DAMD_VER"]
             if version >= 2:
-                data["norm"] = fd["NORM"].data.astype(float)
+                data["norm"] = fd["NORM"].data.astype(np.float32)
             else:
-                data["norm"] = np.ones_like(data["flux"], dtype=float)
+                data["norm"] = np.ones_like(data["flux"], dtype=np.float32)
             data["identity"] = Identity.fromFits(fd)
 
         data["flags"] = MaskHelper.fromFitsHeader(data["metadata"])
@@ -283,10 +283,18 @@ def writeFits(self, filename):
         header = astropyHeaderFromDict(header)
         header['DAMD_VER'] = (2, "PfsFiberArraySet datamodel version")
         fits.append(astropy.io.fits.PrimaryHDU(header=header))
-        for attr in ("fiberId", "wavelength", "flux", "mask", "sky", "norm", "covar"):
+        for attr, dtype in (
+            ("fiberId", np.int32),
+            ("wavelength", float),
+            ("flux", np.float32),
+            ("mask", np.uint32),
+            ("sky", np.float32),
+            ("norm", np.float32),
+            ("covar", np.float32)
+        ):
             hduName = attr.upper()
             data = getattr(self, attr)
-            fits.append(astropy.io.fits.ImageHDU(data, name=hduName))
+            fits.append(astropy.io.fits.ImageHDU(data.astype(dtype), name=hduName))
 
         self.identity.toFits(fits)
         with open(filename, "wb") as fd:
@@ -332,11 +340,11 @@ def fromMerge(cls, spectraList, metadata=None):
         length = length.pop()
         fiberId = np.empty(num, dtype=int)
         wavelength = np.empty((num, length), dtype=float)
-        flux = np.empty((num, length), dtype=float)
-        mask = np.empty((num, length), dtype=int)
-        sky = np.empty((num, length), dtype=float)
-        norm = np.empty((num, length), dtype=float)
-        covar = np.empty((num, 3, length), dtype=float)
+        flux = np.empty((num, length), dtype=np.float32)
+        mask = np.empty((num, length), dtype=np.int32)
+        sky = np.empty((num, length), dtype=np.float32)
+        norm = np.empty((num, length), dtype=np.float32)
+        covar = np.empty((num, 3, length), dtype=np.float32)
         index = 0
         for ss in spectraList:
             select = slice(index, index + len(ss))

python/pfs/datamodel/pfsFiberProfiles.py

@@ -36,7 +36,7 @@ class PfsFiberProfiles:
         that fiber. ``P = int(2*(radius + 1)*oversample) + 1``. The
         profile arrays may be of type `numpy.ma.masked_array`, in order to
         indicate profile values that should be ignored.
-    norm : iterable (length ``N``) of array_like of `float` (length ``Q``)
+    norm : iterable (length ``N``) of array_like of `float32` (length ``Q``)
         Normalisation to apply when extracting spectrum from the image. ``Q``
         is the height of the detector; or it may be ``0`` if no normalisation
         is to be applied.
@@ -156,7 +156,7 @@ def _readImpl(cls, fits, identity):
         fiberId1 = hdu.data["fiberId"].astype(np.int32)
         radius = hdu.data["radius"].astype(np.int32)
         oversample = hdu.data["oversample"].astype(float)
-        norm = [nn.astype(float) for nn in hdu.data["norm"]]
+        norm = [nn.astype(np.float32) for nn in hdu.data["norm"]]
 
         hdu = fits["PROFILES"]
         fiberId2 = hdu.data["fiberId"].astype(np.int32)
@@ -278,7 +278,7 @@ def _writeImpl(self):
             astropy.io.fits.Column("fiberId", format="J", array=self.fiberId),
             astropy.io.fits.Column("radius", format="J", array=self.radius),
             astropy.io.fits.Column("oversample", format="D", array=self.oversample),
-            astropy.io.fits.Column("norm", format="PD()", array=self.norm),
+            astropy.io.fits.Column("norm", format="PE()", array=self.norm),
         ], name="FIBERS")
         fibersHdu.header["INHERIT"] = True
 

python/pfs/datamodel/pfsFluxReference.py

@@ -204,7 +204,7 @@ def fits_getdata(hdulist, name, dtype=None, needHeader=False):
 
         with astropy.io.fits.open(filename) as fd:
             data["fiberId"] = fits_getdata(fd, "fiberId", dtype=np.int32)
-            data["flux"], wcsHeader = fits_getdata(fd, "flux", dtype=np.float, needHeader=True)
+            data["flux"], wcsHeader = fits_getdata(fd, "flux", dtype=np.float32, needHeader=True)
             data["fitFlag"], flagHeader = fits_getdata(fd, "fitFlag", dtype=np.int32, needHeader=True)
             data["fitParams"] = fits_getdata(fd, "fitParams")
             data["identity"] = Identity.fromFits(fd)

python/pfs/datamodel/pfsSimpleSpectrum.py

@@ -80,7 +80,7 @@ def _readImpl(cls, fits):
             Keyword arguments for constructing spectrum.
         """
         data = {}
-        data["flux"] = fits["FLUX"].data.astype(float)
+        data["flux"] = fits["FLUX"].data.astype(np.float32)
         data["mask"] = fits["MASK"].data.astype(np.int32)
 
         # Wavelength can be specified in an explicit extension, or as a WCS in the header
@@ -174,7 +174,7 @@ def _writeImpl(self, fits):
 
         if self.metadata:
             header.extend(astropyHeaderFromDict(self.metadata))
-        fits.append(ImageHDU(self.flux, header=header, name="FLUX"))
+        fits.append(ImageHDU(self.flux.astype(np.float32), header=header, name="FLUX"))
         maskHeader = astropyHeaderFromDict(self.flags.toFitsHeader())
         maskHeader.extend(header)
         fits.append(ImageHDU(self.mask, header=maskHeader, name="MASK"))