Inheritance diagram for lsst.pipe.tasks.extended_psf.StackBrightStarsTask:

Public Member Functions
	removeInvalidStamps (self, read_stars)

	run (self, bss_ref_list, stars_dict, region_name=None)

Static Public Attributes
	ConfigClass = StackBrightStarsConfig

Protected Member Functions
	_set_up_stacking (self, example_stamp)

Static Protected Attributes
str	_DefaultName = "stack_bright_stars"

Detailed Description

Stack bright stars together to build an extended PSF model.

Definition at line 364 of file extended_psf.py.

Member Function Documentation

◆ _set_up_stacking()

lsst.pipe.tasks.extended_psf.StackBrightStarsTask._set_up_stacking	(		self,
			example_stamp )

protected

Configure stacking statistic and control from config fields.

Definition at line 370 of file extended_psf.py.

    def _set_up_stacking(self, example_stamp):
        """Configure stacking statistic and control from config fields."""
        stats_control = StatisticsControl(
            numSigmaClip=self.config.num_sigma_clip,
            numIter=self.config.num_iter,
        )
        if bad_masks := self.config.bad_mask_planes:
            and_mask = example_stamp.mask.getPlaneBitMask(bad_masks[0])
            for bm in bad_masks[1:]:
                and_mask = and_mask | example_stamp.mask.getPlaneBitMask(bm)
            stats_control.setAndMask(and_mask)
        stats_flags = stringToStatisticsProperty(self.config.stacking_statistic)
        return stats_control, stats_flags
 

◆ removeInvalidStamps()

lsst.pipe.tasks.extended_psf.StackBrightStarsTask.removeInvalidStamps	(		self,
			read_stars )

Remove stamps that do not have enough valid pixels in the annulus.

Parameters
----------
read_stars : `list` of `lsst.pipe.tasks.processBrightStars.BrightStarStamp`
    List of bright star stamps to be stacked.

Definition at line 384 of file extended_psf.py.

    def removeInvalidStamps(self, read_stars):
        """Remove stamps that do not have enough valid pixels in the annulus.
 
        Parameters
        ----------
        read_stars : `list` of `lsst.pipe.tasks.processBrightStars.BrightStarStamp`
            List of bright star stamps to be stacked.
        """
        # Find stamps that do not have enough valid pixels in the annulus
        invalidStamps = []
        for stamp in read_stars:
            if stamp.validAnnulusFraction < self.config.minValidAnnulusFraction:
                invalidStamps.append(stamp)
        # Remove stamps that do not have enough valid pixels in the annulus
        if len(invalidStamps):
            for invalidStamp in invalidStamps:
                read_stars._stamps.remove(invalidStamp)
 

◆ run()

lsst.pipe.tasks.extended_psf.StackBrightStarsTask.run	(	self,
		bss_ref_list,
		stars_dict,
		region_name = None )

Read input bright star stamps and stack them together.

The stacking is done iteratively over smaller areas of the final model
image to allow for a great number of bright star stamps to be used.

Parameters
----------
bss_ref_list : `list` of
        `lsst.daf.butler._deferredDatasetHandle.DeferredDatasetHandle`
    List of available bright star stamps data references.
stars_dict: `dict`
    Dictionary to store the number of stars used to generate the PSF.
region_name : `str`, optional
    Name of the focal plane region, if applicable. Only used for
    logging purposes, when running over multiple such regions
    (typically from `MeasureExtendedPsfTask`)

Definition at line 402 of file extended_psf.py.

    def run(self, bss_ref_list, stars_dict, region_name=None):
        """Read input bright star stamps and stack them together.
 
        The stacking is done iteratively over smaller areas of the final model
        image to allow for a great number of bright star stamps to be used.
 
        Parameters
        ----------
        bss_ref_list : `list` of
                `lsst.daf.butler._deferredDatasetHandle.DeferredDatasetHandle`
            List of available bright star stamps data references.
        stars_dict: `dict`
            Dictionary to store the number of stars used to generate the PSF.
        region_name : `str`, optional
            Name of the focal plane region, if applicable. Only used for
            logging purposes, when running over multiple such regions
            (typically from `MeasureExtendedPsfTask`)
        """
        if region_name:
            region_message = f" for region '{region_name}'."
        else:
            region_message = "."
        if region_name is not None:
            stars_dict_key = region_name
        else:
            stars_dict_key = "all"
        self.log.info(
            "Building extended PSF from stamps extracted from %d detector images%s",
            len(bss_ref_list),
            region_message,
        )
        # read in example set of full stamps
        example_bss = bss_ref_list[0].get()
        example_stamp = example_bss[0].stamp_im
        # create model image
        ext_psf = MaskedImageF(example_stamp.getBBox())
        # divide model image into smaller subregions
        subregion_size = Extent2I(*self.config.subregion_size)
        sub_bboxes = subBBoxIter(ext_psf.getBBox(), subregion_size)
        # compute approximate number of subregions
        n_subregions = ((ext_psf.getDimensions()[0]) // (subregion_size[0] + 1)) * (
            (ext_psf.getDimensions()[1]) // (subregion_size[1] + 1)
        )
        self.log.info(
            "Stacking performed iteratively over approximately %d smaller areas of the final model image.",
            n_subregions,
        )
        # set up stacking statistic
        stats_control, stats_flags = self._set_up_stacking(example_stamp)
        # perform stacking
        for jbbox, bbox in enumerate(sub_bboxes):
            all_stars = None
            for bss_ref in bss_ref_list:
                read_stars = bss_ref.get(parameters={"bbox": bbox})
                self.removeInvalidStamps(read_stars)
                if jbbox == 0:
                    # Store the number of stars used to generate the PSF model
                    # in the metadata dictionary.
                    stars_dict[stars_dict_key] += len(read_stars)
                if self.config.do_mag_cut:
                    read_stars = read_stars.selectByMag(magMax=self.config.mag_limit)
                if all_stars:
                    all_stars.extend(read_stars)
                else:
                    all_stars = read_stars
            # TODO: DM-27371 add weights to bright stars for stacking
            coadd_sub_bbox = statisticsStack(all_stars.getMaskedImages(), stats_flags, stats_control)
            ext_psf.assign(coadd_sub_bbox, bbox)
        return ext_psf
 
 

Member Data Documentation

◆ _DefaultName

str lsst.pipe.tasks.extended_psf.StackBrightStarsTask._DefaultName = "stack_bright_stars"

staticprotected

Definition at line 368 of file extended_psf.py.

◆ ConfigClass

lsst.pipe.tasks.extended_psf.StackBrightStarsTask.ConfigClass = StackBrightStarsConfig

static

Definition at line 367 of file extended_psf.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/gd96a1ce819+42fd0ee607/python/lsst/pipe/tasks/extended_psf.py

Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Attributes