Merge pull request #988 from lsst/tickets/DM-46708

TallJimbo · web-flow · commit b1119819f1b7 · 2024-10-08T14:11:19.000-04:00
DM-46708: un-deprecate MakeWarpTask
diff --git a/python/lsst/pipe/tasks/makeWarp.py b/python/lsst/pipe/tasks/makeWarp.py
@@ -31,7 +31,6 @@
 import lsst.pipe.base.connectionTypes as connectionTypes
 import lsst.utils as utils
 import lsst.geom
-from deprecated.sphinx import deprecated
 from lsst.daf.butler import DeferredDatasetHandle
 from lsst.meas.base import DetectorVisitIdGeneratorConfig
 from lsst.meas.algorithms import CoaddPsf, CoaddPsfConfig, GaussianPsfFactory
@@ -109,8 +108,6 @@ def __init__(self, *, config=None):
             del self.psfMatched
 
 
-@deprecated(reason="The Task corresponding to this Config is no longer in use. Will be removed after v28.",
-            version="v28.0", category=FutureWarning)
 class MakeWarpConfig(pipeBase.PipelineTaskConfig, CoaddBaseTask.ConfigClass,
                      pipelineConnections=MakeWarpConnections):
     """Config for MakeWarpTask."""
@@ -197,9 +194,6 @@ def setDefaults(self):
         self.warpAndPsfMatch.psfMatch.kernel.active.kernelSize = self.matchingKernelSize
 
 
-@deprecated(reason="The MakeWarpTask is replaced by MakeDirectWarpTask and MakePsfMatchedWarpTask. "
-                   "This Task will be removed after v28.",
-            version="v28.0", category=FutureWarning)
 class MakeWarpTask(CoaddBaseTask):
     """Warp and optionally PSF-Match calexps onto an a common projection.
 
diff --git a/python/lsst/pipe/tasks/warpAndPsfMatch.py b/python/lsst/pipe/tasks/warpAndPsfMatch.py
@@ -26,13 +26,10 @@
 import lsst.geom as geom
 import lsst.afw.geom as afwGeom
 import lsst.pipe.base as pipeBase
-from deprecated.sphinx import deprecated
 from lsst.ip.diffim import ModelPsfMatchTask
 from lsst.meas.algorithms import WarpedPsf
 
 
-@deprecated(reason="The Task corresponding to this Config is no longer in use. Will be removed after v28.",
-            version="v28.0", category=FutureWarning)
 class WarpAndPsfMatchConfig(pexConfig.Config):
     """Config for WarpAndPsfMatchTask
     """
@@ -46,9 +43,6 @@ class WarpAndPsfMatchConfig(pexConfig.Config):
     )
 
 
-@deprecated(reason="The WarpAndPsfMatchTask is no longer in use. Will be removed after v28. "
-            "Use MakeDirectWarp and MakePsfMatchedWarp instead.",
-            version="v28.0", category=FutureWarning)
 class WarpAndPsfMatchTask(pipeBase.Task):
     """A task to warp and PSF-match an exposure
     """
diff --git a/tests/test_makeWarp.py b/tests/test_makeWarp.py
@@ -0,0 +1,292 @@
+# This file is part of pipe_tasks.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import unittest
+
+from typing import Self, Type
+
+import numpy as np
+
+import lsst.utils.tests
+
+import lsst.afw.image
+from lsst.daf.butler import DataCoordinate, DimensionUniverse
+from lsst.pipe.base import InMemoryDatasetHandle
+from lsst.pipe.tasks.make_direct_warp import MakeDirectWarpTask
+from lsst.pipe.tasks.makeWarp import (MakeWarpTask, MakeWarpConfig)
+from lsst.pipe.tasks.coaddBase import makeSkyInfo
+import lsst.skymap as skyMap
+from lsst.afw.detection import GaussianPsf
+import lsst.afw.cameraGeom.testUtils
+
+
+class MakeWarpTestCase(lsst.utils.tests.TestCase):
+    def setUp(self):
+        np.random.seed(12345)
+
+        self.config = MakeWarpConfig()
+
+        meanCalibration = 1e-4
+        calibrationErr = 1e-5
+        self.exposurePhotoCalib = lsst.afw.image.PhotoCalib(meanCalibration, calibrationErr)
+        # An external photoCalib calibration to return
+        self.externalPhotoCalib = lsst.afw.image.PhotoCalib(1e-6, 1e-8)
+
+        crpix = lsst.geom.Point2D(0, 0)
+        crval = lsst.geom.SpherePoint(0, 45, lsst.geom.degrees)
+        cdMatrix = lsst.afw.geom.makeCdMatrix(scale=1.0*lsst.geom.arcseconds)
+        self.skyWcs = lsst.afw.geom.makeSkyWcs(crpix, crval, cdMatrix)
+        externalCdMatrix = lsst.afw.geom.makeCdMatrix(scale=0.9*lsst.geom.arcseconds)
+        # An external skyWcs to return
+        self.externalSkyWcs = lsst.afw.geom.makeSkyWcs(crpix, crval, externalCdMatrix)
+
+        self.exposure = lsst.afw.image.ExposureF(100, 150)
+        self.exposure.maskedImage.image.array = np.random.random((150, 100)).astype(np.float32) * 1000
+        self.exposure.maskedImage.variance.array = np.random.random((150, 100)).astype(np.float32)
+        # mask at least one pixel
+        self.exposure.maskedImage.mask[5, 5] = 3
+        # set the PhotoCalib and Wcs objects of this exposure.
+        self.exposure.setPhotoCalib(lsst.afw.image.PhotoCalib(meanCalibration, calibrationErr))
+        self.exposure.setWcs(self.skyWcs)
+        self.exposure.setPsf(GaussianPsf(5, 5, 2.5))
+        self.exposure.setFilter(lsst.afw.image.FilterLabel(physical="fakeFilter", band="fake"))
+
+        self.visit = 100
+        self.detector = 5
+        detectorName = f"detector {self.detector}"
+        detector = lsst.afw.cameraGeom.testUtils.DetectorWrapper(name=detectorName, id=self.detector).detector
+        self.exposure.setDetector(detector)
+
+        simpleMapConfig = skyMap.discreteSkyMap.DiscreteSkyMapConfig()
+        simpleMapConfig.raList = [crval.getRa().asDegrees()]
+        simpleMapConfig.decList = [crval.getDec().asDegrees()]
+        simpleMapConfig.radiusList = [0.1]
+
+        self.simpleMap = skyMap.DiscreteSkyMap(simpleMapConfig)
+        self.tractId = 0
+        self.patchId = self.simpleMap[0].findPatch(crval).sequential_index
+        self.skyInfo = makeSkyInfo(self.simpleMap, self.tractId, self.patchId)
+
+    @classmethod
+    def generate_data_id(
+        cls: Type[Self],
+        *,
+        tract: int = 9813,
+        patch: int = 42,
+        band: str = "r",
+        detector_id: int = 9,
+        visit_id: int = 1234,
+        detector_max: int = 109,
+        visit_max: int = 10000
+    ) -> DataCoordinate:
+        """Generate a DataCoordinate instance to use as data_id.
+
+        Parameters
+        ----------
+        tract : `int`, optional
+            Tract ID for the data_id
+        patch : `int`, optional
+            Patch ID for the data_id
+        band : `str`, optional
+            Band for the data_id
+        detector_id : `int`, optional
+            Detector ID for the data_id
+        visit_id : `int`, optional
+            Visit ID for the data_id
+        detector_max : `int`, optional
+            Maximum detector ID for the data_id
+        visit_max : `int`, optional
+            Maximum visit ID for the data_id
+
+        Returns
+        -------
+        data_id : `lsst.daf.butler.DataCoordinate`
+            An expanded data_id instance.
+        """
+        universe = DimensionUniverse()
+
+        instrument = universe["instrument"]
+        instrument_record = instrument.RecordClass(
+            name="DummyCam",
+            class_name="lsst.obs.base.instrument_tests.DummyCam",
+            detector_max=detector_max,
+            visit_max=visit_max,
+        )
+
+        skymap = universe["skymap"]
+        skymap_record = skymap.RecordClass(name="test_skymap")
+
+        band_element = universe["band"]
+        band_record = band_element.RecordClass(name=band)
+
+        visit = universe["visit"]
+        visit_record = visit.RecordClass(id=visit_id, instrument="test")
+
+        detector = universe["detector"]
+        detector_record = detector.RecordClass(id=detector_id, instrument="test")
+
+        physical_filter = universe["physical_filter"]
+        physical_filter_record = physical_filter.RecordClass(name=band, instrument="test", band=band)
+
+        patch_element = universe["patch"]
+        patch_record = patch_element.RecordClass(
+            skymap="test_skymap", tract=tract, patch=patch,
+        )
+
+        if "day_obs" in universe:
+            day_obs_element = universe["day_obs"]
+            day_obs_record = day_obs_element.RecordClass(id=20240201, instrument="test")
+        else:
+            day_obs_record = None
+
+        # A dictionary with all the relevant records.
+        record = {
+            "instrument": instrument_record,
+            "visit": visit_record,
+            "detector": detector_record,
+            "patch": patch_record,
+            "tract": 9813,
+            "band": band_record.name,
+            "skymap": skymap_record.name,
+            "physical_filter": physical_filter_record,
+        }
+
+        if day_obs_record:
+            record["day_obs"] = day_obs_record
+
+        # A dictionary with all the relevant recordIds.
+        record_id = record.copy()
+        for key in ("visit", "detector"):
+            record_id[key] = record_id[key].id
+
+        # TODO: Catching mypy failures on Github Actions should be made easier,
+        # perhaps in DM-36873. Igroring these for now.
+        data_id = DataCoordinate.standardize(record_id, universe=universe)
+        return data_id.expanded(record)
+
+    def test_makeWarp(self):
+        """Test basic MakeWarpTask."""
+        makeWarp = MakeWarpTask(config=self.config)
+
+        result = makeWarp.run(
+            calExpList=[self.exposure],
+            ccdIdList=[self.detector],
+            skyInfo=self.skyInfo,
+            visitId=self.visit,
+            dataIdList=[{'visit': self.visit, 'detector': self.detector}],
+        )
+
+        warp = result.exposures['direct']
+
+        # Ensure we got an exposure out
+        self.assertIsInstance(warp, lsst.afw.image.ExposureF)
+        # Ensure the warp has valid pixels
+        self.assertGreater(np.isfinite(warp.image.array.ravel()).sum(), 0)
+        # Ensure the warp has the correct WCS
+        self.assertEqual(warp.getWcs(), self.skyInfo.wcs)
+
+    def test_psfMatched(self):
+        """Test that the direct warp is independent of makePsfMatched config.
+        """
+        self.config.makePsfMatched = False
+        task1 = MakeWarpTask(config=self.config)
+        self.config.makePsfMatched = True
+        task2 = MakeWarpTask(config=self.config)
+
+        result1 = task1.run(
+            calExpList=[self.exposure],
+            ccdIdList=[self.detector],
+            skyInfo=self.skyInfo,
+            visitId=self.visit,
+            dataIdList=[{'visit': self.visit, 'detector': self.detector}],
+        )
+
+        result2 = task2.run(
+            calExpList=[self.exposure],
+            ccdIdList=[self.detector],
+            skyInfo=self.skyInfo,
+            visitId=self.visit,
+            dataIdList=[{'visit': self.visit, 'detector': self.detector}],
+        )
+
+        # Ensure we got a valid exposure out
+        warp = result2.exposures['psfMatched']
+        self.assertIsInstance(warp, lsst.afw.image.ExposureF)
+        self.assertGreater(np.isfinite(warp.image.array.ravel()).sum(), 0)
+        # Check that the direct images are the same.
+        self.assertMaskedImagesEqual(
+            result1.exposures['direct'].maskedImage,
+            result2.exposures['direct'].maskedImage
+        )
+
+    def test_compare_warps(self):
+        """Test that the warp from MakeWarpTask and MakeDirectWarpTask agree.
+        """
+        dataIdList = [{'visit_id': self.visit, 'detector_id': self.detector, "band": "i"}]
+
+        dataRefs = [
+            InMemoryDatasetHandle(self.exposure, dataId=self.generate_data_id(**dataId))
+            for dataId in dataIdList
+        ]
+        inputs = {"calexp_list": dataRefs}
+
+        for dataId in dataIdList:
+            dataId["detector"] = dataId.pop("detector_id")
+            dataId["visit"] = dataId.pop("visit_id")
+
+        self.config.makePsfMatched = True
+        makeWarp = MakeWarpTask(config=self.config)
+        result0 = makeWarp.run(
+            calExpList=[self.exposure],
+            ccdIdList=[self.detector],
+            skyInfo=self.skyInfo,
+            visitId=self.visit,
+            dataIdList=dataIdList,
+        )
+
+        config = MakeDirectWarpTask.ConfigClass()
+        config.doPreWarpInterpolation = False
+        config.doSelectPreWarp = False
+        config.useVisitSummaryPsf = False
+        task = MakeDirectWarpTask(config=config)
+        result1 = task.run(
+            inputs,
+            sky_info=self.skyInfo,
+            visit_summary=None
+        )
+
+        warp0 = result0.exposures["direct"]
+        warp1 = result1.warp[warp0.getBBox()]
+
+        self.assertMaskedImagesAlmostEqual(warp0.maskedImage, warp1.maskedImage, rtol=3e-7, atol=6e-6)
+
+
+def setup_module(module):
+    lsst.utils.tests.init()
+
+
+class MatchMemoryTestCase(lsst.utils.tests.MemoryTestCase):
+    pass
+
+
+if __name__ == "__main__":
+    lsst.utils.tests.init()
+    unittest.main()
