lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin Class Reference

Inheritance diagram for lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin:

Public Member Functions
	getExecutionOrder (cls)
	__init__ (self, SingleFrameCompensatedTophatFluxConfig config, str name, schema, metadata, logName=None, **kwds)
	fail (self, measRecord, error=None)
	measure (self, measRecord, exposure)

Public Attributes
	aperture_keys
	flagHandler

Static Public Attributes
	ConfigClass = SingleFrameCompensatedTophatFluxConfig

Protected Attributes
	_rads
	_inner_scale
	_outer_scale
	_max_rad

Detailed Description

Definition at line 70 of file _compensatedTophat.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.__init__	(		self,
		SingleFrameCompensatedTophatFluxConfig	config,
		str	name,
			schema,
			metadata,
			logName = None,
		**	kwds )

Reimplemented from lsst.meas.base.sfm.SingleFramePlugin.

Definition at line 77 of file _compensatedTophat.py.

    ):
        super().__init__(config, name, schema, metadata, logName, **kwds)
 
        flagDefs = FlagDefinitionList()
 
        self.aperture_keys = {}
        self._rads = {}
        self._inner_scale = config.inner_scale
        self._outer_scale = config.outer_scale
        for aperture in config.apertures:
            base_key = f"{name}_{aperture}"
 
            # flux
            flux_str = f"{base_key}_instFlux"
            flux_key = schema.addField(
                flux_str,
                type="D",
                doc="Compensated Tophat flux measurement.",
                units="count",
            )
 
            # flux error
            err_str = f"{base_key}_instFluxErr"
            err_key = schema.addField(
                err_str,
                type="D",
                doc="Compensated Tophat flux error.",
                units="count",
            )
 
            # mask bits
            mask_str = f"{base_key}_mask_bits"
            mask_key = schema.addField(mask_str, type=np.int32, doc="Mask bits set within aperture.")
 
            # failure flags
            failure_flag = flagDefs.add(f"{aperture}_flag", "Compensated Tophat measurement failed")
            oob_flag = flagDefs.add(f"{aperture}_flag_bounds", "Compensated Tophat out-of-bounds")
 
            self.aperture_keys[aperture] = (flux_key, err_key, mask_key, failure_flag, oob_flag)
            self._rads[aperture] = int(math.ceil(self._outer_scale*aperture))
 
        self.flagHandler = FlagHandler.addFields(schema, name, flagDefs)
        self._max_rad = max(self._rads)
 

Member Function Documentation

fail()

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.fail	(		self,
			measRecord,
			error = None )

Record a failure of the `measure` or `measureN` method.

Parameters
----------
measRecord : `lsst.afw.table.SourceRecord`
    Table record describing the source being measured.
error : `MeasurementError`, optional
    Only provided if the measurement failed due to a
    `MeasurementError` being raised; otherwise, will be `None`.

Notes
-----
When the plugin raises an exception, framework will call
`BasePlugin.fail` to allow the plugin to set its failure flag
field(s).  When `BasePlugin.measureN` raises an exception,
`BasePlugin.fail` will be called repeatedly with all the records that
were being measured.

If the exception is an `MeasurementError`, it will be passed as the
error argument; in all other cases the error argument will be `None`,
and the failure will be logged by the measurement framework as a
warning.

Reimplemented from lsst.meas.base.pluginsBase.BasePlugin.

Definition at line 129 of file _compensatedTophat.py.

    def fail(self, measRecord, error=None):
        if error is None:
            self.flagHandler.handleFailure(measRecord)
        else:
            self.flagHandler.handleFailure(measRecord, error.cpp)
 

getExecutionOrder()

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.getExecutionOrder

(

cls

)

Get the relative execution order of this plugin.

Must be reimplemented as a class method by concrete derived classes.

Reimplemented from lsst.meas.base.pluginsBase.BasePlugin.

Definition at line 74 of file _compensatedTophat.py.

    def getExecutionOrder(cls):
        return cls.FLUX_ORDER
 

measure()

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.measure	(		self,
			measRecord,
			exposure )

Measure the properties of a source on a single image.

The image may be from a single epoch, or it may be a coadd.

Parameters
----------
measRecord : `lsst.afw.table.SourceRecord`
    Record describing the object being measured. Previously-measured
    quantities may be retrieved from here, and it will be updated
    in-place tih the outputs of this plugin.
exposure : `lsst.afw.image.ExposureF`
    The pixel data to be measured, together with the associated PSF,
    WCS, etc. All other sources in the image should have been replaced
    by noise according to deblender outputs.

Reimplemented from lsst.meas.base.sfm.SingleFramePlugin.

Definition at line 135 of file _compensatedTophat.py.

    def measure(self, measRecord, exposure):
        center = measRecord.getCentroid()
        bbox = exposure.getBBox()
 
        y = center.getY() - bbox.beginY
        x = center.getX() - bbox.beginX
 
        y_floor = math.floor(y)
        x_floor = math.floor(x)
 
        ctrl = ApertureFluxAlgorithm.Control()
 
        for aperture, (flux_key, err_key, mask_key, failure_flag, oob_flag) in self.aperture_keys.items():
            rad = self._rads[aperture]
 
            # This will fail if even a single pixel is outside the bounding
            # box.
            if Point2I(center) not in exposure.getBBox().erodedBy(rad):
                self.flagHandler.setValue(measRecord, failure_flag.number, True)
                self.flagHandler.setValue(measRecord, oob_flag.number, True)
                continue
 
            # We confirmed that the bounding box is sufficient to hold these
            # slices, so no additional range checking is needed.
            y_slice = slice(y_floor - rad, y_floor + rad + 1, 1)
            x_slice = slice(x_floor - rad, x_floor + rad + 1, 1)
 
            # We will need the mask below, we can use this to test bounds as
            # well.
            sub_mask = exposure.mask.array[y_slice, x_slice]
 
            if sub_mask.size == 0 or sub_mask.shape[0] != sub_mask.shape[1] or (sub_mask.shape[0] % 2) == 0:
                self.flagHandler.setValue(measRecord, failure_flag.number, True)
                self.flagHandler.setValue(measRecord, oob_flag.number, True)
                continue
 
            # Compute three aperture fluxes.
            ellipse = lsst.afw.geom.Ellipse(lsst.afw.geom.ellipses.Axes(float(aperture),
                                                                        float(aperture), 0.0),
                                            center)
            tophat = ApertureFluxAlgorithm.computeFlux(exposure.maskedImage, ellipse, ctrl)
            ellipse.grow((self._inner_scale - 1.0)*aperture)
            inner = ApertureFluxAlgorithm.computeFlux(exposure.maskedImage, ellipse, ctrl)
            ellipse.grow((self._outer_scale - self._inner_scale)*aperture)
            outer = ApertureFluxAlgorithm.computeFlux(exposure.maskedImage, ellipse, ctrl)
 
            # We have flux in 3 circular apertures, a_0, a_1, a_2 with
            # associated variances \sigma_{a_0}^2, \sigma_{a_1}^2,
            # \sigma_{a_2)^2.

Member Data Documentation

_inner_scale

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin._inner_scale

protected

Definition at line 92 of file _compensatedTophat.py.

_max_rad

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin._max_rad

protected

Definition at line 127 of file _compensatedTophat.py.

_outer_scale

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin._outer_scale

protected

Definition at line 93 of file _compensatedTophat.py.

_rads

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin._rads

protected

Definition at line 91 of file _compensatedTophat.py.

aperture_keys

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.aperture_keys

Definition at line 90 of file _compensatedTophat.py.

ConfigClass

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.ConfigClass = SingleFrameCompensatedTophatFluxConfig

static

Definition at line 71 of file _compensatedTophat.py.

flagHandler

lsst.meas.base.compensatedGaussian._compensatedTophat.SingleFrameCompensatedTophatFluxPlugin.flagHandler

Definition at line 126 of file _compensatedTophat.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/meas_base/g5a97de2502+520531a62c/python/lsst/meas/base/compensatedGaussian/_compensatedTophat.py