lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask Class Reference

Inheritance diagram for lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask:

Public Member Functions
	__init__ (self, **kwargs)
	build_ccd_input_map (self, bbox, wcs, ccds)
	mask_warp_bbox (self, bbox, visit, mask, bit_mask_value)
	finalize_ccd_input_map_mask (self)

Public Attributes
	ccd_input_map

Static Public Attributes
	ConfigClass = HealSparseInputMapConfig

Protected Member Functions
	_pixels_to_radec (self, wcs, pixels)

Protected Attributes
	_wcs
	_bbox
	_ccds
	_min_bad
	_bits_per_visit_ccd
	_bits_per_visit
	_ccd_input_pixels
	_ccd_input_bad_count_map

Static Protected Attributes
str	_DefaultName = "healSparseInputMap"

Detailed Description

Task for making a HealSparse input map.

Definition at line 132 of file healSparseMapping.py.

Constructor & Destructor Documentation

__init__()

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.__init__	(		self,
		**	kwargs )

Definition at line 138 of file healSparseMapping.py.

    def __init__(self, **kwargs):
        pipeBase.Task.__init__(self, **kwargs)
 
        self.ccd_input_map = None
 

Member Function Documentation

_pixels_to_radec()

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._pixels_to_radec ( self, wcs, pixels )

protected

Convert pixels to ra/dec positions using a wcs.

Parameters
----------
wcs : `lsst.afw.geom.SkyWcs`
    WCS object.
pixels : `list` [`lsst.geom.Point2D`]
    List of pixels to convert.

Returns
-------
radec : `numpy.ndarray`
    Nx2 array of ra/dec positions associated with pixels.

Definition at line 305 of file healSparseMapping.py.

    def _pixels_to_radec(self, wcs, pixels):
        """Convert pixels to ra/dec positions using a wcs.
 
        Parameters
        ----------
        wcs : `lsst.afw.geom.SkyWcs`
            WCS object.
        pixels : `list` [`lsst.geom.Point2D`]
            List of pixels to convert.
 
        Returns
        -------
        radec : `numpy.ndarray`
            Nx2 array of ra/dec positions associated with pixels.
        """
        sph_pts = wcs.pixelToSky(pixels)
        return np.array([(sph.getRa().asDegrees(), sph.getDec().asDegrees())
                         for sph in sph_pts])
 
 

build_ccd_input_map()

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.build_ccd_input_map	(		self,
			bbox,
			wcs,
			ccds )

Build a map from ccd valid polygons or bounding boxes.

Parameters
----------
bbox : `lsst.geom.Box2I`
    Bounding box for region to build input map.
wcs : `lsst.afw.geom.SkyWcs`
    WCS object for region to build input map.
ccds : `lsst.afw.table.ExposureCatalog`
    Exposure catalog with ccd data from coadd inputs.

Definition at line 143 of file healSparseMapping.py.

    def build_ccd_input_map(self, bbox, wcs, ccds):
        """Build a map from ccd valid polygons or bounding boxes.
 
        Parameters
        ----------
        bbox : `lsst.geom.Box2I`
            Bounding box for region to build input map.
        wcs : `lsst.afw.geom.SkyWcs`
            WCS object for region to build input map.
        ccds : `lsst.afw.table.ExposureCatalog`
            Exposure catalog with ccd data from coadd inputs.
        """
        with warnings.catch_warnings():
            # Healsparse will emit a warning if nside coverage is greater than
            # 128.  In the case of generating patch input maps, and not global
            # maps, high nside coverage works fine, so we can suppress this
            # warning.
            warnings.simplefilter("ignore")
            self.ccd_input_map = hsp.HealSparseMap.make_empty(nside_coverage=self.config.nside_coverage,
                                                              nside_sparse=self.config.nside,
                                                              dtype=hsp.WIDE_MASK,
                                                              wide_mask_maxbits=len(ccds))
        self._wcs = wcs
        self._bbox = bbox
        self._ccds = ccds
 
        pixel_scale = wcs.getPixelScale().asArcseconds()
        hpix_area_arcsec2 = hpg.nside_to_pixel_area(self.config.nside, degrees=True)*(3600.**2.)
        self._min_bad = self.config.bad_mask_min_coverage*hpix_area_arcsec2/(pixel_scale**2.)
 
        metadata = {}
        self._bits_per_visit_ccd = {}
        self._bits_per_visit = defaultdict(list)
        for bit, ccd_row in enumerate(ccds):
            metadata[f"B{bit:04d}CCD"] = ccd_row["ccd"]
            metadata[f"B{bit:04d}VIS"] = ccd_row["visit"]
            metadata[f"B{bit:04d}WT"] = ccd_row["weight"]
 
            self._bits_per_visit_ccd[(ccd_row["visit"], ccd_row["ccd"])] = bit
            self._bits_per_visit[ccd_row["visit"]].append(bit)
 
            ccd_poly = ccd_row.getValidPolygon()
            if ccd_poly is None:
                ccd_poly = afwGeom.Polygon(lsst.geom.Box2D(ccd_row.getBBox()))
            # Detectors need to be rendered with their own wcs.
            ccd_poly_radec = self._pixels_to_radec(ccd_row.getWcs(), ccd_poly.convexHull().getVertices())
 
            # Create a ccd healsparse polygon
            poly = hsp.Polygon(ra=ccd_poly_radec[: -1, 0],
                               dec=ccd_poly_radec[: -1, 1],
                               value=[bit])
            self.ccd_input_map.set_bits_pix(poly.get_pixels(nside=self.ccd_input_map.nside_sparse),
                                            [bit])
 
        # Cut down to the overall bounding box with associated wcs.
        bbox_afw_poly = afwGeom.Polygon(lsst.geom.Box2D(bbox))
        bbox_poly_radec = self._pixels_to_radec(self._wcs,
                                                bbox_afw_poly.convexHull().getVertices())
        bbox_poly = hsp.Polygon(ra=bbox_poly_radec[: -1, 0], dec=bbox_poly_radec[: -1, 1],
                                value=np.arange(self.ccd_input_map.wide_mask_maxbits))
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            bbox_poly_map = bbox_poly.get_map_like(self.ccd_input_map)
            self.ccd_input_map = hsp.and_intersection([self.ccd_input_map, bbox_poly_map])
        self.ccd_input_map.metadata = metadata
 
        # Create a temporary map to hold the count of bad pixels in each healpix pixel
        self._ccd_input_pixels = self.ccd_input_map.valid_pixels
 
        dtype = [(f"v{visit}", np.int64) for visit in self._bits_per_visit.keys()]
 
        with warnings.catch_warnings():
            # Healsparse will emit a warning if nside coverage is greater than
            # 128.  In the case of generating patch input maps, and not global
            # maps, high nside coverage works fine, so we can suppress this
            # warning.
            warnings.simplefilter("ignore")
            self._ccd_input_bad_count_map = hsp.HealSparseMap.make_empty(
                nside_coverage=self.config.nside_coverage,
                nside_sparse=self.config.nside,
                dtype=dtype,
                primary=dtype[0][0])
 
        # Don't set input bad map if there are no ccds which overlap the bbox.
        if len(self._ccd_input_pixels) > 0:
            self._ccd_input_bad_count_map[self._ccd_input_pixels] = np.zeros(1, dtype=dtype)
 

finalize_ccd_input_map_mask()

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.finalize_ccd_input_map_mask

(

self

)

Use accumulated mask information to finalize the masking of
ccd_input_map.

Raises
------
RuntimeError : Raised if build_ccd_input_map was not run first.

Definition at line 283 of file healSparseMapping.py.

    def finalize_ccd_input_map_mask(self):
        """Use accumulated mask information to finalize the masking of
        ccd_input_map.
 
        Raises
        ------
        RuntimeError : Raised if build_ccd_input_map was not run first.
        """
        if self.ccd_input_map is None:
            raise RuntimeError("Must run build_ccd_input_map before finalize_ccd_input_map_mask.")
 
        count_map_arr = self._ccd_input_bad_count_map[self._ccd_input_pixels]
        for visit in self._bits_per_visit:
            to_mask, = np.where(count_map_arr[f"v{visit}"] > self._min_bad)
            if to_mask.size == 0:
                continue
            self.ccd_input_map.clear_bits_pix(self._ccd_input_pixels[to_mask],
                                              self._bits_per_visit[visit])
 
        # Clear memory
        self._ccd_input_bad_count_map = None
 

mask_warp_bbox()

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.mask_warp_bbox	(		self,
			bbox,
			visit,
			mask,
			bit_mask_value )

Mask a subregion from a visit.
This must be run after build_ccd_input_map initializes
the overall map.

Parameters
----------
bbox : `lsst.geom.Box2I`
    Bounding box from region to mask.
visit : `int`
    Visit number corresponding to warp with mask.
mask : `lsst.afw.image.MaskX`
    Mask plane from warp exposure.
bit_mask_value : `int`
    Bit mask to check for bad pixels.

Raises
------
RuntimeError : Raised if build_ccd_input_map was not run first.

Definition at line 230 of file healSparseMapping.py.

    def mask_warp_bbox(self, bbox, visit, mask, bit_mask_value):
        """Mask a subregion from a visit.
        This must be run after build_ccd_input_map initializes
        the overall map.
 
        Parameters
        ----------
        bbox : `lsst.geom.Box2I`
            Bounding box from region to mask.
        visit : `int`
            Visit number corresponding to warp with mask.
        mask : `lsst.afw.image.MaskX`
            Mask plane from warp exposure.
        bit_mask_value : `int`
            Bit mask to check for bad pixels.
 
        Raises
        ------
        RuntimeError : Raised if build_ccd_input_map was not run first.
        """
        if self.ccd_input_map is None:
            raise RuntimeError("Must run build_ccd_input_map before mask_warp_bbox")
 
        # Find the bad pixels and convert to healpix
        bad_pixels = np.where(mask.array & bit_mask_value)
        if len(bad_pixels[0]) == 0:
            # No bad pixels
            return
 
        # Bad pixels come from warps which use the overall wcs.
        bad_ra, bad_dec = self._wcs.pixelToSkyArray(bad_pixels[1].astype(np.float64),
                                                    bad_pixels[0].astype(np.float64),
                                                    degrees=True)
        bad_hpix = hpg.angle_to_pixel(self.config.nside, bad_ra, bad_dec)
 
        # Count the number of bad image pixels in each healpix pixel
        min_bad_hpix = bad_hpix.min()
        bad_hpix_count = np.zeros(bad_hpix.max() - min_bad_hpix + 1, dtype=np.int32)
        np.add.at(bad_hpix_count, bad_hpix - min_bad_hpix, 1)
 
        # Add these to the accumulator map.
        # We need to make sure that the "primary" array has valid values for
        # this pixel to be registered in the accumulator map.
        pix_to_add, = np.where(bad_hpix_count > 0)
        count_map_arr = self._ccd_input_bad_count_map[min_bad_hpix + pix_to_add]
        primary = self._ccd_input_bad_count_map.primary
        count_map_arr[primary] = np.clip(count_map_arr[primary], 0, None)
 
        count_map_arr[f"v{visit}"] = np.clip(count_map_arr[f"v{visit}"], 0, None)
        count_map_arr[f"v{visit}"] += bad_hpix_count[pix_to_add]
 
        self._ccd_input_bad_count_map[min_bad_hpix + pix_to_add] = count_map_arr
 

Member Data Documentation

_bbox

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._bbox

protected

Definition at line 166 of file healSparseMapping.py.

_bits_per_visit

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._bits_per_visit

protected

Definition at line 175 of file healSparseMapping.py.

_bits_per_visit_ccd

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._bits_per_visit_ccd

protected

Definition at line 174 of file healSparseMapping.py.

_ccd_input_bad_count_map

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._ccd_input_bad_count_map

protected

Definition at line 220 of file healSparseMapping.py.

_ccd_input_pixels

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._ccd_input_pixels

protected

Definition at line 210 of file healSparseMapping.py.

_ccds

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._ccds

protected

Definition at line 167 of file healSparseMapping.py.

_DefaultName

str lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._DefaultName = "healSparseInputMap"

staticprotected

Definition at line 136 of file healSparseMapping.py.

_min_bad

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._min_bad

protected

Definition at line 171 of file healSparseMapping.py.

_wcs

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask._wcs

protected

Definition at line 165 of file healSparseMapping.py.

ccd_input_map

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.ccd_input_map

Definition at line 141 of file healSparseMapping.py.

ConfigClass

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.ConfigClass = HealSparseInputMapConfig

static

Definition at line 135 of file healSparseMapping.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/pipe_tasks/gc07e1c2157+b2dbe6b631/python/lsst/pipe/tasks/healSparseMapping.py