lsst.meas.algorithms.simple_curve.AmpCurve Class Reference

Inheritance diagram for lsst.meas.algorithms.simple_curve.AmpCurve:

Public Member Functions
	__init__ (self, amp_name_list, wavelength, efficiency, metadata)
	__eq__ (self, other)
	fromTable (cls, table)
	toTable (self)
	evaluate (self, detector, position, wavelength, kind='linear', bounds_error=False, fill_value=0)

Public Attributes
	data

Static Public Attributes
str	mode = 'AMP'

Detailed Description

Subclass of `Curve` that represents a curve per amp.

Parameters
----------
amp_name_list : iterable of `str`
    The name of the amp for each entry
wavelength : `astropy.units.Quantity`
    Wavelength values for this curve
efficiency : `astropy.units.Quantity`
    Quantum efficiency values for this curve
metadata : `dict`
    Dictionary of metadata for this curve

Definition at line 331 of file simple_curve.py.

Constructor & Destructor Documentation

__init__()

lsst.meas.algorithms.simple_curve.AmpCurve.__init__	(		self,
			amp_name_list,
			wavelength,
			efficiency,
			metadata )

Reimplemented from lsst.meas.algorithms.simple_curve.Curve.

Definition at line 347 of file simple_curve.py.

    def __init__(self, amp_name_list, wavelength, efficiency, metadata):
        super().__init__(wavelength, efficiency, metadata)
        amp_names = set(amp_name_list)
        self.data = {}
        for amp_name in sorted(amp_names):
            idx = numpy.where(amp_name_list == amp_name)[0]
            # Deal with the case where the keys are bytes from FITS
            name = amp_name
            if isinstance(name, bytes):
                name = name.decode()
            self.data[name] = (wavelength[idx], efficiency[idx])
 

Member Function Documentation

__eq__()

lsst.meas.algorithms.simple_curve.AmpCurve.__eq__	(		self,
			other )

Define equality for this class

Reimplemented from lsst.meas.algorithms.simple_curve.Curve.

Definition at line 359 of file simple_curve.py.

    def __eq__(self, other):
        if not self.compare_metadata(other):
            return False
        for k in self.data:
            if not numpy.array_equal(self.data[k][0], other.data[k][0]):
                return False
            if not numpy.array_equal(self.data[k][1], other.data[k][1]):
                return False
        return True
 

evaluate()

lsst.meas.algorithms.simple_curve.AmpCurve.evaluate	(		self,
			detector,
			position,
			wavelength,
			kind = 'linear',
			bounds_error = False,
			fill_value = 0 )

Interpolate the curve at the specified position and wavelength.

Parameters
----------
detector : `lsst.afw.cameraGeom.Detector`
    Is used to find the appropriate curve given the position for
    curves that vary over the detector.  Ignored in the case where
    there is only a single curve per detector.
position : `lsst.geom.Point2D`
    The position on the detector at which to evaluate the curve.
wavelength : `astropy.units.Quantity`
    The wavelength(s) at which to make the interpolation.
kind : `str`, optional
    The type of interpolation to do (default is 'linear').
    See documentation for `scipy.interpolate.interp1d` for
    accepted values.
bounds_error : `bool`, optional
    Raise error if interpolating outside the range of x?
    (default is False)
fill_value : `float`, optional
    Fill values outside the range of x with this value
    (default is 0).

Returns
-------
value : `astropy.units.Quantity`
    Interpolated value(s).  Number of values returned will match the
    length of `wavelength`.

Raises
------
ValueError
    If the ``bounds_error`` is changed from the default, it will raise
    a `ValueError` if evaluating outside the bounds of the curve.

Reimplemented from lsst.meas.algorithms.simple_curve.Curve.

Definition at line 401 of file simple_curve.py.

    def evaluate(self, detector, position, wavelength, kind='linear', bounds_error=False, fill_value=0):
        # Docstring inherited from base classs
        amp = cgUtils.findAmp(detector, Point2I(position))  # cast to Point2I if Point2D passed
        w, e = self.data[amp.getName()]
        return self.interpolate(w, e, wavelength, kind=kind, bounds_error=bounds_error,
                                fill_value=fill_value)
 
 

fromTable()

lsst.meas.algorithms.simple_curve.AmpCurve.fromTable	(		cls,
			table )

Class method for constructing a `Curve` object.

Parameters
----------
table : `astropy.table.QTable`
    Table containing metadata and columns necessary
    for constructing a `Curve` object.

Returns
-------
curve : `Curve`
    A `Curve` subclass of the appropriate type according
    to the table metadata

Reimplemented from lsst.meas.algorithms.simple_curve.Curve.

Definition at line 370 of file simple_curve.py.

    def fromTable(cls, table):
        # Docstring inherited from base classs
        cls._check_cols(['amp_name', 'wavelength', 'efficiency'], table)
        return cls(table['amp_name'], table['wavelength'],
                   table['efficiency'], table.meta)
 

toTable()

lsst.meas.algorithms.simple_curve.AmpCurve.toTable

(

self

)

Convert this `Curve` object to an `astropy.table.QTable`.

Returns
-------
table : `astropy.table.QTable`
    A table object containing the data from this `Curve`.

Reimplemented from lsst.meas.algorithms.simple_curve.Curve.

Definition at line 376 of file simple_curve.py.

    def toTable(self):
        # Docstring inherited from base classs
        wavelength = None
        efficiency = None
        names = numpy.array([])
        # Loop over the amps and concatenate into three same length columns to feed
        # to the Table constructor.
        for amp_name, val in self.data.items():
            # This will preserve the quantity
            if wavelength is None:
                wunit = val[0].unit
                wavelength = val[0].value
            else:
                wavelength = numpy.concatenate([wavelength, val[0].value])
            if efficiency is None:
                eunit = val[1].unit
                efficiency = val[1].value
            else:
                efficiency = numpy.concatenate([efficiency, val[1].value])
            names = numpy.concatenate([names, numpy.full(val[0].shape, amp_name)])
        names = numpy.array(names)
        # Note that in future, the astropy.unit should make it through concatenation
        return QTable({'amp_name': names, 'wavelength': wavelength*wunit, 'efficiency': efficiency*eunit},
                      meta=self.metadata)
 

Member Data Documentation

data

lsst.meas.algorithms.simple_curve.AmpCurve.data

Definition at line 350 of file simple_curve.py.

mode

str lsst.meas.algorithms.simple_curve.AmpCurve.mode = 'AMP'

static

Definition at line 345 of file simple_curve.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_algorithms/ge6526c86ff+bcc88f9437/python/lsst/meas/algorithms/simple_curve.py