lsst.pipe.tasks.healSparseMappingProperties Namespace Reference

Classes
class	BasePropertyMapConfig
class	PropertyMapRegistry
class	PropertyMapMap
class	BasePropertyMap
class	ExposureTimePropertyMap
class	PsfSizePropertyMap
class	PsfE1PropertyMap
class	PsfE2PropertyMap
class	NExposurePropertyMap
class	PsfMaglimPropertyMapConfig
class	PsfMaglimPropertyMap
class	SkyBackgroundPropertyMap
class	SkyNoisePropertyMap
class	DcrDraPropertyMap
class	DcrDdecPropertyMap
class	DcrE1PropertyMap
class	DcrE2PropertyMap

Functions
def	register_property_map (name)
def	compute_approx_psf_size_and_shape (ccd_row, ra, dec, nx=20, ny=20, orderx=2, ordery=2)

Function Documentation

compute_approx_psf_size_and_shape()

def lsst.pipe.tasks.healSparseMappingProperties.compute_approx_psf_size_and_shape	(		ccd_row,
			ra,
			dec,
			nx = 20,
			ny = 20,
			orderx = 2,
			ordery = 2
	)

Compute the approximate psf size and shape.

This routine fits how the psf size and shape varies over a field by approximating
with a Chebyshev bounded field.

Parameters
----------
ccd_row : `lsst.afw.table.ExposureRecord`
    Exposure metadata for a given detector exposure.
ra : `np.ndarray`
    Right ascension of points to compute size and shape (degrees).
dec : `np.ndarray`
    Declination of points to compute size and shape (degrees).
nx : `int`, optional
    Number of sampling points in the x direction.
ny : `int`, optional
    Number of sampling points in the y direction.
orderx : `int`, optional
    Chebyshev polynomial order for fit in x direction.
ordery : `int`, optional
    Chebyshev polynomial order for fit in y direction.

Returns
-------
psf_array : `np.ndarray`
    Record array with "psf_size", "psf_e1", "psf_e2".

Definition at line 99 of file healSparseMappingProperties.py.

def compute_approx_psf_size_and_shape(ccd_row, ra, dec, nx=20, ny=20, orderx=2, ordery=2):
    """Compute the approximate psf size and shape.
 
    This routine fits how the psf size and shape varies over a field by approximating
    with a Chebyshev bounded field.
 
    Parameters
    ----------
    ccd_row : `lsst.afw.table.ExposureRecord`
        Exposure metadata for a given detector exposure.
    ra : `np.ndarray`
        Right ascension of points to compute size and shape (degrees).
    dec : `np.ndarray`
        Declination of points to compute size and shape (degrees).
    nx : `int`, optional
        Number of sampling points in the x direction.
    ny : `int`, optional
        Number of sampling points in the y direction.
    orderx : `int`, optional
        Chebyshev polynomial order for fit in x direction.
    ordery : `int`, optional
        Chebyshev polynomial order for fit in y direction.
 
    Returns
    -------
    psf_array : `np.ndarray`
        Record array with "psf_size", "psf_e1", "psf_e2".
    """
    pts = [lsst.geom.SpherePoint(r*lsst.geom.degrees, d*lsst.geom.degrees) for
           r, d in zip(ra, dec)]
    pixels = ccd_row.getWcs().skyToPixel(pts)
 
    ctrl = ChebyshevBoundedFieldControl()
    ctrl.orderX = orderx
    ctrl.orderY = ordery
    ctrl.triangular = False
 
    bbox = ccd_row.getBBox()
    xSteps = np.linspace(bbox.getMinX(), bbox.getMaxX(), nx)
    ySteps = np.linspace(bbox.getMinY(), bbox.getMaxY(), ny)
    x = np.tile(xSteps, nx)
    y = np.repeat(ySteps, ny)
 
    psf_size = np.zeros(x.size)
    psf_e1 = np.zeros(x.size)
    psf_e2 = np.zeros(x.size)
    psf_area = np.zeros(x.size)
 
    psf = ccd_row.getPsf()
    for i in range(x.size):
        shape = psf.computeShape(lsst.geom.Point2D(x[i], y[i]))
        psf_size[i] = shape.getDeterminantRadius()
        ixx = shape.getIxx()
        iyy = shape.getIyy()
        ixy = shape.getIxy()
 
        psf_e1[i] = (ixx - iyy)/(ixx + iyy + 2.*psf_size[i]**2.)
        psf_e2[i] = (2.*ixy)/(ixx + iyy + 2.*psf_size[i]**2.)
 
        im = psf.computeKernelImage(lsst.geom.Point2D(x[i], y[i]))
        psf_area[i] = np.sum(im.array)/np.sum(im.array**2.)
 
    pixel_x = np.array([pix.getX() for pix in pixels])
    pixel_y = np.array([pix.getY() for pix in pixels])
 
    psf_array = np.zeros(pixel_x.size, dtype=[("psf_size", "f8"),
                                              ("psf_e1", "f8"),
                                              ("psf_e2", "f8"),
                                              ("psf_area", "f8")])
 
    cheb_size = ChebyshevBoundedField.fit(lsst.geom.Box2I(bbox), x, y, psf_size, ctrl)
    psf_array["psf_size"] = cheb_size.evaluate(pixel_x, pixel_y)
    cheb_e1 = ChebyshevBoundedField.fit(lsst.geom.Box2I(bbox), x, y, psf_e1, ctrl)
    psf_array["psf_e1"] = cheb_e1.evaluate(pixel_x, pixel_y)
    cheb_e2 = ChebyshevBoundedField.fit(lsst.geom.Box2I(bbox), x, y, psf_e2, ctrl)
    psf_array["psf_e2"] = cheb_e2.evaluate(pixel_x, pixel_y)
    cheb_area = ChebyshevBoundedField.fit(lsst.geom.Box2I(bbox), x, y, psf_area, ctrl)
    psf_array["psf_area"] = cheb_area.evaluate(pixel_x, pixel_y)
 
    return psf_array
 
 

register_property_map()

def lsst.pipe.tasks.healSparseMappingProperties.register_property_map

(

name

)

A decorator to register a property map class in its base class's registry.

Definition at line 91 of file healSparseMappingProperties.py.

def register_property_map(name):
    """A decorator to register a property map class in its base class's registry."""
    def decorate(PropertyMapClass):
        PropertyMapClass.registry.register(name, PropertyMapClass)
        return PropertyMapClass
    return decorate