lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask Class Reference

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

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

Public Attributes
	ccd_input_map

Static Public Attributes
	ConfigClass = HealSparseInputMapConfig

Detailed Description

Task for making a HealSparse input map.

Definition at line 131 of file healSparseMapping.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 137 of file healSparseMapping.py.

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

Member Function Documentation

build_ccd_input_map()

def 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 142 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.
        """
        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 = hp.nside2pixarea(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))
        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}", "i4") for visit in self._bits_per_visit.keys()]
 
        cov = self.config.nside_coverage
        ns = self.config.nside
        self._ccd_input_bad_count_map = hsp.HealSparseMap.make_empty(nside_coverage=cov,
                                                                     nside_sparse=ns,
                                                                     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()

def 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 269 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()

def 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 215 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 = hp.ang2pix(self.config.nside, bad_ra, bad_dec,
                              lonlat=True, nest=True)
 
        # 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

ccd_input_map

lsst.pipe.tasks.healSparseMapping.HealSparseInputMapTask.ccd_input_map

Definition at line 140 of file healSparseMapping.py.

ConfigClass

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

static

Definition at line 134 of file healSparseMapping.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/pipe_tasks/21.0.0-147-g0e635eb1+1acddb5be5/python/lsst/pipe/tasks/healSparseMapping.py