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.