lsst.scarlet.lite.initialization.FactorizedChi2Initialization Class Reference

Inheritance diagram for lsst.scarlet.lite.initialization.FactorizedChi2Initialization:

Public Member Functions
	__init__ (self, Observation observation, Sequence[tuple[int, int]] centers, np.ndarray|None detect=None, float min_snr=50, Monotonicity|None monotonicity=None, float disk_percentile=25, float thresh=0.5, int padding=2)
Source|None	init_source (self, tuple[int, int] center)

Public Attributes
	detect
	disk_percentile
	thresh
	padding
	observation

Detailed Description

Initialize all sources with chi^2 detections

There are a large number of parameters that are universal for all of the
sources being initialized from the same set of observed images.
To simplify the API those parameters are all initialized by this class
and passed to `init_main_source` for each source.
It also creates temporary objects that only need to be created once for
all of the sources in a blend.

Parameters
----------
observation:
    The observation containing the blend
centers:
    The center of each source to initialize.
detect:
    The array that contains a 2D image used for detection.
min_snr:
    The minimum SNR required per component.
    So a 2-component source requires at least `2*min_snr` while sources
    with SNR < `min_snr` will be initialized with the PSF.
monotonicity:
    When `monotonicity` is `None`,
    the component is initialized with only the
    monotonic pixels, otherwise the monotonicity operator is used to
    project the morphology to a monotonic solution.
disk_percentile:
    The percentage of the overall flux to attribute to the disk.
thresh:
    The threshold used to trim the morphology,
    so all pixels below `thresh * bg_rms` are set to zero.
padding:
    The amount to pad the morphology to allow for extra flux
    in the first few iterations before resizing.

Definition at line 399 of file initialization.py.

Constructor & Destructor Documentation

__init__()

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.__init__	(		self,
		Observation	observation,
		Sequence[tuple[int, int]]	centers,
		np.ndarray | None	detect = None,
		float	min_snr = 50,
		Monotonicity | None	monotonicity = None,
		float	disk_percentile = 25,
		float	thresh = 0.5,
		int	padding = 2 )

Reimplemented from lsst.scarlet.lite.initialization.FactorizedInitialization.

Definition at line 436 of file initialization.py.

    ):
        if detect is None:
            # Build the morphology detection image
            detect = np.sum(
                observation.images.data / (observation.noise_rms**2)[:, None, None],
                axis=0,
            )
        self.detect = detect
        _detect = Image(detect)
        # Convolve the detection image.
        # This may seem counter-intuitive,
        # since this is effectively growing the model,
        # but this is exactly what convolution will do to the model
        # in each iteration.
        # So we create the convolved model in order
        # to correctly set the spectrum.
        convolved = observation.convolve(_detect.repeat(observation.bands), mode="real")
 
        # Set the input parameters
        self.disk_percentile = disk_percentile
        self.thresh = thresh
        self.padding = padding
 
        # Initialize the sources
        super().__init__(observation, convolved, centers, min_snr, monotonicity)
 

Member Function Documentation

init_source()

Source | None lsst.scarlet.lite.initialization.FactorizedChi2Initialization.init_source	(		self,
		tuple[int, int]	center )

Initialize a source from a chi^2 detection.

Parameter
---------
center:
    The center of the source.
init:
    The initialization parameters common to all of the sources.
max_components:
    The maximum number of components in the source.

Reimplemented from lsst.scarlet.lite.initialization.FactorizedInitialization.

Definition at line 472 of file initialization.py.

    def init_source(self, center: tuple[int, int]) -> Source | None:
        """Initialize a source from a chi^2 detection.
 
        Parameter
        ---------
        center:
            The center of the source.
        init:
            The initialization parameters common to all of the sources.
        max_components:
            The maximum number of components in the source.
        """
        # Some operators need the local center, not center in the full image
        local_center = (
            center[0] - self.observation.bbox.origin[0],
            center[1] - self.observation.bbox.origin[1],
        )
 
        # Calculate the signal to noise at the center of this source
        component_snr = self.get_snr(center)
 
        # Initialize the bbox, morph, and spectrum
        # for a single component source
        detect = prox_uncentered_symmetry(self.detect.copy(), local_center, fill=0)
        thresh = np.mean(self.observation.noise_rms) * self.thresh
        component = self.get_single_component(center, detect, thresh, self.padding)
 
        if component is None:
            components = [self.get_psf_component(center)]
        elif component_snr < 2:
            components = [component]
        else:
            # There was enough flux for a 2-component source,
            # so split the single component model into two components,
            # using the same algorithm as scarlet main.
            bulge_morph = component.morph.copy()
            disk_morph = component.morph
            # Set the threshold for the bulge.
            # Since the morphology is monotonic, this selects the inner
            # of the single component morphology and assigns it to the bulge.
            flux_thresh = self.disk_percentile / 100
            mask = disk_morph > flux_thresh
            # Remove the flux above the threshold so that the disk will have
            # a flat center.
            disk_morph[mask] = flux_thresh
            # Subtract off the thresholded flux (since we're normalizing the
            # morphology anyway) so that it does not have a sharp
            # discontinuity at the edge.
            bulge_morph -= flux_thresh
            bulge_morph[bulge_morph < 0] = 0
 
            bulge_morph /= np.max(bulge_morph)
            disk_morph /= np.max(disk_morph)
 
            # Fit the spectra assuming that all of the flux in the image
            # is due to both components. This is not true, but for the
            # vast majority of sources this is a good approximation.
            bulge_spectrum, disk_spectrum = multifit_spectra(
                self.observation,
                [
                    Image(bulge_morph, yx0=cast(tuple[int, int], component.bbox.origin)),
                    Image(disk_morph, yx0=cast(tuple[int, int], component.bbox.origin)),
                ],
            )
 
            components = [
                FactorizedComponent(
                    self.observation.bands,
                    bulge_spectrum,
                    bulge_morph,
                    component.bbox.copy(),
                    center,
                    self.observation.noise_rms,
                    monotonicity=self.monotonicity,
                ),
                FactorizedComponent(
                    self.observation.bands,
                    disk_spectrum,
                    disk_morph,
                    component.bbox.copy(),
                    center,
                    self.observation.noise_rms,
                    monotonicity=self.monotonicity,
                ),
            ]
 
        return Source(components)  # type: ignore
 
 

Member Data Documentation

detect

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.detect

Definition at line 453 of file initialization.py.

disk_percentile

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.disk_percentile

Definition at line 465 of file initialization.py.

observation

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.observation

Definition at line 530 of file initialization.py.

padding

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.padding

Definition at line 467 of file initialization.py.

thresh

lsst.scarlet.lite.initialization.FactorizedChi2Initialization.thresh

Definition at line 466 of file initialization.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/scarlet_lite/gae0086650b+585e252eca/python/lsst/scarlet/lite/initialization.py