lsst.pipe.tasks.coaddBase Namespace Reference

Classes
class	CoaddBaseConfig
class	CoaddBaseTask

Functions
	makeSkyInfo (skyMap, tractId, patchId)
	reorderAndPadList (inputList, inputKeys, outputKeys, padWith=None)
	reorderRefs (inputRefs, outputSortKeyOrder, dataIdKey)
	subBBoxIter (bbox, subregionSize)
None	growValidPolygons (coaddInputs, int growBy)
	removeMaskPlanes (afwImage.Mask mask, Iterable mask_planes, Logger|None logger=None)
list[tuple[int, int]]	setRejectedMaskMapping (StatisticsControl statsCtrl)

Function Documentation

growValidPolygons()

None lsst.pipe.tasks.coaddBase.growValidPolygons	(		coaddInputs,
		int	growBy )

Grow coaddInputs' ccds' ValidPolygons in place.

Either modify each ccd's validPolygon in place, or if CoaddInputs
does not have a validPolygon, create one from its bbox.

Parameters
----------
coaddInputs : `lsst.afw.image.coaddInputs`
    CoaddInputs object containing the ccds to grow the valid polygons of.
growBy : `int`
    The value to grow the valid polygons by.

Notes
-----
Negative values for ``growBy`` can shrink the polygons.

Definition at line 274 of file coaddBase.py.

def growValidPolygons(coaddInputs, growBy: int) -> None:
    """Grow coaddInputs' ccds' ValidPolygons in place.
 
    Either modify each ccd's validPolygon in place, or if CoaddInputs
    does not have a validPolygon, create one from its bbox.
 
    Parameters
    ----------
    coaddInputs : `lsst.afw.image.coaddInputs`
        CoaddInputs object containing the ccds to grow the valid polygons of.
    growBy : `int`
        The value to grow the valid polygons by.
 
    Notes
    -----
    Negative values for ``growBy`` can shrink the polygons.
    """
    for ccd in coaddInputs.ccds:
        polyOrig = ccd.getValidPolygon()
        validPolyBBox = polyOrig.getBBox() if polyOrig else ccd.getBBox()
        validPolyBBox.grow(growBy)
        if polyOrig:
            validPolygon = polyOrig.intersectionSingle(validPolyBBox)
        else:
            validPolygon = Polygon(geom.Box2D(validPolyBBox))
 
        ccd.validPolygon = validPolygon
 
 

makeSkyInfo()

lsst.pipe.tasks.coaddBase.makeSkyInfo	(		skyMap,
			tractId,
			patchId )

Constructs SkyInfo used by coaddition tasks for multiple
patchId formats.

Parameters
----------
skyMap : `lsst.skyMap.SkyMap`
    Sky map.
tractId : `int`
    The ID of the tract.
patchId : `str` or `int` or `tuple` of `int`
    Either Gen2-style comma delimited string (e.g. '4,5'),
    tuple of integers (e.g (4, 5), Gen3-style integer.

Returns
-------
makeSkyInfo : `lsst.pipe.base.Struct`
    pipe_base Struct with attributes:

    ``skyMap``
        Sky map (`lsst.skyMap.SkyMap`).
    ``tractInfo``
        Information for chosen tract of sky map (`lsst.skyMap.TractInfo`).
    ``patchInfo``
        Information about chosen patch of tract (`lsst.skyMap.PatchInfo`).
    ``wcs``
        WCS of tract (`lsst.afw.image.SkyWcs`).
    ``bbox``
        Outer bbox of patch, as an geom Box2I (`lsst.afw.geom.Box2I`).

Definition at line 112 of file coaddBase.py.

def makeSkyInfo(skyMap, tractId, patchId):
    """Constructs SkyInfo used by coaddition tasks for multiple
    patchId formats.
 
    Parameters
    ----------
    skyMap : `lsst.skyMap.SkyMap`
        Sky map.
    tractId : `int`
        The ID of the tract.
    patchId : `str` or `int` or `tuple` of `int`
        Either Gen2-style comma delimited string (e.g. '4,5'),
        tuple of integers (e.g (4, 5), Gen3-style integer.
 
    Returns
    -------
    makeSkyInfo : `lsst.pipe.base.Struct`
        pipe_base Struct with attributes:
 
        ``skyMap``
            Sky map (`lsst.skyMap.SkyMap`).
        ``tractInfo``
            Information for chosen tract of sky map (`lsst.skyMap.TractInfo`).
        ``patchInfo``
            Information about chosen patch of tract (`lsst.skyMap.PatchInfo`).
        ``wcs``
            WCS of tract (`lsst.afw.image.SkyWcs`).
        ``bbox``
            Outer bbox of patch, as an geom Box2I (`lsst.afw.geom.Box2I`).
    """
    tractInfo = skyMap[tractId]
 
    if isinstance(patchId, str) and ',' in patchId:
        #  patch format is "xIndex,yIndex"
        patchIndex = tuple(int(i) for i in patchId.split(","))
    else:
        patchIndex = patchId
 
    patchInfo = tractInfo.getPatchInfo(patchIndex)
 
    return pipeBase.Struct(
        skyMap=skyMap,
        tractInfo=tractInfo,
        patchInfo=patchInfo,
        wcs=tractInfo.getWcs(),
        bbox=patchInfo.getOuterBBox(),
    )
 
 

removeMaskPlanes()

lsst.pipe.tasks.coaddBase.removeMaskPlanes	(	afwImage.Mask	mask,
		Iterable	mask_planes,
		Logger | None	logger = None )

Unset the mask of an image for mask planes specified in the config.

Parameters
----------
mask : `lsst.afw.image.Mask`
    The mask to be modified.
mask_planes : `list`
    The list of mask planes to be removed.
logger : `logging.Logger`, optional
    Logger to log messages.

Definition at line 303 of file coaddBase.py.

):
    """Unset the mask of an image for mask planes specified in the config.
 
    Parameters
    ----------
    mask : `lsst.afw.image.Mask`
        The mask to be modified.
    mask_planes : `list`
        The list of mask planes to be removed.
    logger : `logging.Logger`, optional
        Logger to log messages.
    """
    for maskPlane in mask_planes:
        try:
            mask &= ~mask.getPlaneBitMask(maskPlane)
        except InvalidParameterError:
            if logger:
                logger.warning(
                    "Unable to remove mask plane %s: no mask plane with that name was found.",
                    maskPlane,
                )
 
 

reorderAndPadList()

lsst.pipe.tasks.coaddBase.reorderAndPadList	(		inputList,
			inputKeys,
			outputKeys,
			padWith = None )

Match the order of one list to another, padding if necessary

Parameters
----------
inputList : `list`
    List to be reordered and padded. Elements can be any type.
inputKeys :  `iterable`
    Iterable of values to be compared with outputKeys. Length must match `inputList`.
outputKeys : `iterable`
    Iterable of values to be compared with inputKeys.
padWith : `Unknown`
    Any value to be inserted where inputKey not in outputKeys.

Returns
-------
outputList : `list`
    Copy of inputList reordered per outputKeys and padded with `padWith`
    so that the length matches length of outputKeys.

Definition at line 161 of file coaddBase.py.

def reorderAndPadList(inputList, inputKeys, outputKeys, padWith=None):
    """Match the order of one list to another, padding if necessary
 
    Parameters
    ----------
    inputList : `list`
        List to be reordered and padded. Elements can be any type.
    inputKeys :  `iterable`
        Iterable of values to be compared with outputKeys. Length must match `inputList`.
    outputKeys : `iterable`
        Iterable of values to be compared with inputKeys.
    padWith : `Unknown`
        Any value to be inserted where inputKey not in outputKeys.
 
    Returns
    -------
    outputList : `list`
        Copy of inputList reordered per outputKeys and padded with `padWith`
        so that the length matches length of outputKeys.
    """
    outputList = []
    for d in outputKeys:
        if d in inputKeys:
            outputList.append(inputList[inputKeys.index(d)])
        else:
            outputList.append(padWith)
    return outputList
 
 

reorderRefs()

lsst.pipe.tasks.coaddBase.reorderRefs	(		inputRefs,
			outputSortKeyOrder,
			dataIdKey )

Reorder inputRefs per outputSortKeyOrder.

Any inputRefs which are lists will be resorted per specified key e.g.,
'detector.' Only iterables will be reordered, and values can be of type
`lsst.pipe.base.connections.DeferredDatasetRef` or
`lsst.daf.butler.core.datasets.ref.DatasetRef`.

Returned lists of refs have the same length as the outputSortKeyOrder.
If an outputSortKey not in the inputRef, then it will be padded with None.
If an inputRef contains an inputSortKey that is not in the
outputSortKeyOrder it will be removed.

Parameters
----------
inputRefs : `lsst.pipe.base.connections.QuantizedConnection`
    Input references to be reordered and padded.
outputSortKeyOrder : `iterable`
    Iterable of values to be compared with inputRef's dataId[dataIdKey].
dataIdKey : `str`
    The data ID key in the dataRefs to compare with the outputSortKeyOrder.

Returns
-------
inputRefs : `lsst.pipe.base.connections.QuantizedConnection`
    Quantized Connection with sorted DatasetRef values sorted if iterable.

Definition at line 190 of file coaddBase.py.

def reorderRefs(inputRefs, outputSortKeyOrder, dataIdKey):
    """Reorder inputRefs per outputSortKeyOrder.
 
    Any inputRefs which are lists will be resorted per specified key e.g.,
    'detector.' Only iterables will be reordered, and values can be of type
    `lsst.pipe.base.connections.DeferredDatasetRef` or
    `lsst.daf.butler.core.datasets.ref.DatasetRef`.
 
    Returned lists of refs have the same length as the outputSortKeyOrder.
    If an outputSortKey not in the inputRef, then it will be padded with None.
    If an inputRef contains an inputSortKey that is not in the
    outputSortKeyOrder it will be removed.
 
    Parameters
    ----------
    inputRefs : `lsst.pipe.base.connections.QuantizedConnection`
        Input references to be reordered and padded.
    outputSortKeyOrder : `iterable`
        Iterable of values to be compared with inputRef's dataId[dataIdKey].
    dataIdKey : `str`
        The data ID key in the dataRefs to compare with the outputSortKeyOrder.
 
    Returns
    -------
    inputRefs : `lsst.pipe.base.connections.QuantizedConnection`
        Quantized Connection with sorted DatasetRef values sorted if iterable.
    """
    for connectionName, refs in inputRefs:
        if isinstance(refs, Iterable):
            if hasattr(refs[0], "dataId"):
                inputSortKeyOrder = [ref.dataId[dataIdKey] for ref in refs]
            else:
                inputSortKeyOrder = [handle.datasetRef.dataId[dataIdKey] for handle in refs]
            if inputSortKeyOrder != outputSortKeyOrder:
                setattr(inputRefs, connectionName,
                        reorderAndPadList(refs, inputSortKeyOrder, outputSortKeyOrder))
    return inputRefs
 
 

setRejectedMaskMapping()

list[tuple[int, int]] lsst.pipe.tasks.coaddBase.setRejectedMaskMapping

(

StatisticsControl

statsCtrl

)

Map certain mask planes of the warps to new planes for the coadd.

If a pixel is rejected due to a mask value other than EDGE, NO_DATA,
or CLIPPED, set it to REJECTED on the coadd.
If a pixel is rejected due to EDGE, set the coadd pixel to SENSOR_EDGE.
If a pixel is rejected due to CLIPPED, set the coadd pixel to CLIPPED.

Parameters
----------
statsCtrl : `lsst.afw.math.StatisticsControl`
    Statistics control object for coadd.

Returns
-------
maskMap : `list` of `tuple` of `int`
    A list of mappings of mask planes of the warped exposures to
    mask planes of the coadd.

Definition at line 328 of file coaddBase.py.

def setRejectedMaskMapping(statsCtrl: StatisticsControl) -> list[tuple[int, int]]:
    """Map certain mask planes of the warps to new planes for the coadd.
 
    If a pixel is rejected due to a mask value other than EDGE, NO_DATA,
    or CLIPPED, set it to REJECTED on the coadd.
    If a pixel is rejected due to EDGE, set the coadd pixel to SENSOR_EDGE.
    If a pixel is rejected due to CLIPPED, set the coadd pixel to CLIPPED.
 
    Parameters
    ----------
    statsCtrl : `lsst.afw.math.StatisticsControl`
        Statistics control object for coadd.
 
    Returns
    -------
    maskMap : `list` of `tuple` of `int`
        A list of mappings of mask planes of the warped exposures to
        mask planes of the coadd.
    """
    edge = 2 ** afwImage.Mask.addMaskPlane("EDGE")
    noData = 2 ** afwImage.Mask.addMaskPlane("NO_DATA")
    clipped = 2 ** afwImage.Mask.addMaskPlane("CLIPPED")
    toReject = statsCtrl.getAndMask() & (~noData) & (~edge) & (~clipped)
    maskMap = [
        (toReject, 2 ** afwImage.Mask.addMaskPlane("REJECTED")),
        (edge, 2 ** afwImage.Mask.addMaskPlane("SENSOR_EDGE")),
        (clipped, clipped),
    ]
    return maskMap

subBBoxIter()

lsst.pipe.tasks.coaddBase.subBBoxIter	(		bbox,
			subregionSize )

Iterate over subregions of a bbox.

Parameters
----------
bbox : `lsst.geom.Box2I`
    Bounding box over which to iterate.
subregionSize : `lsst.geom.Extent2I`
    Size of sub-bboxes.

Yields
------
subBBox : `lsst.geom.Box2I`
    Next sub-bounding box of size ``subregionSize`` or smaller; each ``subBBox``
    is contained within ``bbox``, so it may be smaller than ``subregionSize`` at
    the edges of ``bbox``, but it will never be empty.

Raises
------
RuntimeError
    Raised if any of the following occur:
    - The given bbox is empty.
    - The subregionSize is 0.

Definition at line 229 of file coaddBase.py.

def subBBoxIter(bbox, subregionSize):
    """Iterate over subregions of a bbox.
 
    Parameters
    ----------
    bbox : `lsst.geom.Box2I`
        Bounding box over which to iterate.
    subregionSize : `lsst.geom.Extent2I`
        Size of sub-bboxes.
 
    Yields
    ------
    subBBox : `lsst.geom.Box2I`
        Next sub-bounding box of size ``subregionSize`` or smaller; each ``subBBox``
        is contained within ``bbox``, so it may be smaller than ``subregionSize`` at
        the edges of ``bbox``, but it will never be empty.
 
    Raises
    ------
    RuntimeError
        Raised if any of the following occur:
        - The given bbox is empty.
        - The subregionSize is 0.
    """
    if bbox.isEmpty():
        raise RuntimeError("bbox %s is empty" % (bbox,))
    if subregionSize[0] < 1 or subregionSize[1] < 1:
        raise RuntimeError("subregionSize %s must be nonzero" % (subregionSize,))
 
    for rowShift in range(0, bbox.getHeight(), subregionSize[1]):
        for colShift in range(0, bbox.getWidth(), subregionSize[0]):
            subBBox = geom.Box2I(bbox.getMin() + geom.Extent2I(colShift, rowShift), subregionSize)
            subBBox.clip(bbox)
            if subBBox.isEmpty():
                raise RuntimeError("Bug: empty bbox! bbox=%s, subregionSize=%s, "
                                   "colShift=%s, rowShift=%s" %
                                   (bbox, subregionSize, colShift, rowShift))
            yield subBBox
 
 
# Note that this is implemented as a free-floating function to enable reuse in
# lsst.pipe.tasks.makeWarp and in lsst.drp.tasks.make_psf_matched_warp
# without creating any relationships between the two classes.
# This may be converted to a method after makeWarp.py is removed altogether in
# DM-47916.