Classes
class	FgcmOutputIlluminationCorrectionConnections

Variables
	camera : `lsst.afw.cameraGeom.camera`

	detector_id : `int`

	fgcm_fit_parameters_catalog : `lsst.afw.SimpleCatalog`

	filter_label_dict : `dict` [`str`: `lsst.afw.image.FilterLabel`]

	flat_metadata_dict : `dict` [`str`: (`uuid.UUID`, `lsst.pipe.base.PropertyList`]

	struct : `lsst.pipe.base.Struct`

Detailed Description

Make an illumination correction from the fgcmcal outputs.

Variable Documentation

◆ camera

lsst.fgcmcal.fgcmOutputIlluminationCorrection.camera : `lsst.afw.cameraGeom.camera`

    use_flat_metadata = lsst.pex.config.Field(
        doc="Use flat-field metadata for illumination correction metadata?",
        dtype=bool,
        default=True,
    )
    epoch_time = lsst.pex.config.Field(
        doc="Time string (UTC) that corresponds to a date in the desired epoch.",
        dtype=str,
        default=None,
        optional=False,
    )
    epoch_format = lsst.pex.config.Field(
        doc="Format for time string (e.g. iso, mjd, etc.), used by astropy.time.Time()",
        dtype=str,
        default="iso",
    )
    physical_filters = lsst.pex.config.ListField(
        doc="List of physical filters to produce illumination corrections.",
        dtype=str,
        default=[],
    )
    include_wcs_jacobian = lsst.pex.config.Field(
        doc="Include WCS jacobian in illumination correction?",
        dtype=bool,
        default=True,
    )
    approximate_wcs_jacobian = lsst.pex.config.Field(
        doc="Use a Chebyshev approximation of the WCS jacobian in illumination correction?",
        dtype=bool,
        default=True,
    )

    def validate(self):
        try:
            _ = Time(self.epoch_time, format=self.epoch_format)
        except Exception as e:
            raise ValueError(
                "Could not parse epoch_time/epoch_format ", e)


class FgcmOutputIlluminationCorrectionTask(PipelineTask):

    ConfigClass = FgcmOutputIlluminationCorrectionConfig
    _DefaultName = "fgcmOutputIlluminationCorrection"

    def runQuantum(self, butlerQC, inputRefs, outputRefs):

        inputs = butlerQC.get(inputRefs)

        detector_id = butlerQC.quantum.dataId["detector"]

        filter_label_dict = {ref.dataId["physical_filter"]:
                             FilterLabel(physical=ref.dataId["physical_filter"], band=ref.dataId["band"])
                             for ref in outputRefs.illumination_corrections}

        flat_metadata_dict = {}
        if self.config.use_flat_metadata:
            for i, flat_metadata in enumerate(inputs["flat_metadata"]):
                ref = inputRefs.flat_metadata[i]
                flat_metadata_dict[ref.dataId["physical_filter"]] = (ref.id, flat_metadata)

        retval = self.run(
            camera=inputs["camera"],
            detector_id=detector_id,
            fgcm_fit_parameters_catalog=inputs["fgcm_fit_parameters_catalog"],
            filter_label_dict=filter_label_dict,
            flat_metadata_dict=flat_metadata_dict,
        )

        # And put the outputs.
        illum_corr_ref_dict = {ref.dataId["physical_filter"]:
                               ref for ref in outputRefs.illumination_corrections}
        for physical_filter in retval.illum_corr_dict:
            if physical_filter in illum_corr_ref_dict:
                self.log.debug(
                    "Serializing illumination correction for detector %d, physical_filter %s",
                    detector_id,
                    physical_filter,
                )
                butlerQC.put(retval.illum_corr_dict[physical_filter], illum_corr_ref_dict[physical_filter])

    def run(
        self,
        *,
        camera,
        detector_id,
        fgcm_fit_parameters_catalog,
        filter_label_dict,
        flat_metadata_dict={},
    ):

Definition at line 212 of file fgcmOutputIlluminationCorrection.py.