Inheritance diagram for lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask:

Public Member Functions
	__init__ (self, refObjLoader=None, refCatName=None, **kwargs)

	getFgcmReferenceStarsHealpix (self, nside, pixel, filterList, nest=False)

	getFgcmReferenceStarsSkyCircle (self, ra, dec, radius, filterList)

Public Attributes
	refObjLoader

	refCatName

Static Public Attributes
	ConfigClass = FgcmLoadReferenceCatalogConfig

Protected Member Functions
	_determine_flux_fields (self, center, filterList)

Protected Attributes
	_fluxFilters

	_fluxFields

	_referenceFilter

Static Protected Attributes
str	_DefaultName = 'fgcmLoadReferenceCatalog'

Detailed Description

Load multi-band reference objects from a reference catalog.

Parameters
----------
refObjLoader : `lsst.meas.algorithms.ReferenceObjectLoader`
    Reference object loader.
refCatName : `str`
    Name of reference catalog (for color term lookups).

Definition at line 81 of file fgcmLoadReferenceCatalog.py.

Constructor & Destructor Documentation

◆ init()

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.__init__	(		self,
			refObjLoader = None,
			refCatName = None,
		**	kwargs )

Construct an FgcmLoadReferenceCatalogTask

Definition at line 95 of file fgcmLoadReferenceCatalog.py.

    def __init__(self, refObjLoader=None, refCatName=None, **kwargs):
        """Construct an FgcmLoadReferenceCatalogTask
        """
        pipeBase.Task.__init__(self, **kwargs)
        self.refObjLoader = refObjLoader
        self.refCatName = refCatName
 
        if refObjLoader is None or refCatName is None:
            raise RuntimeError("FgcmLoadReferenceCatalogTask requires a refObjLoader and refCatName.")
 
        self.makeSubtask('referenceSelector')
        self._fluxFilters = None
        self._fluxFields = None
        self._referenceFilter = None
 

Member Function Documentation

◆ _determine_flux_fields()

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask._determine_flux_fields	(	self,
		center,
		filterList )

protected

Determine the flux field names for a reference catalog.

Will set self._fluxFields, self._referenceFilter.

Parameters
----------
center: `lsst.geom.SpherePoint`
   The center around which to load test sources.
filterList: `list`
   list of `str` of camera filter names.

Definition at line 273 of file fgcmLoadReferenceCatalog.py.

    def _determine_flux_fields(self, center, filterList):
        """
        Determine the flux field names for a reference catalog.
 
        Will set self._fluxFields, self._referenceFilter.
 
        Parameters
        ----------
        center: `lsst.geom.SpherePoint`
           The center around which to load test sources.
        filterList: `list`
           list of `str` of camera filter names.
        """
 
        # Record self._fluxFilters for checks on subsequent calls
        self._fluxFilters = filterList
 
        # Search for a good filter to use to load the reference catalog
        # via the refObjLoader task which requires a valid filterName
        foundReferenceFilter = False
        for filterName in filterList:
            refFilterName = self.config.filterMap.get(filterName)
            if refFilterName is None:
                continue
 
            try:
                results = self.refObjLoader.loadSkyCircle(center,
                                                          0.05 * lsst.geom.degrees,
                                                          refFilterName)
                foundReferenceFilter = True
                self._referenceFilter = refFilterName
                break
            except RuntimeError:
                # This just means that the filterName wasn't listed
                # in the reference catalog.  This is okay.
                pass
 
        if not foundReferenceFilter:
            raise RuntimeError("Could not find any valid flux field(s) %s" %
                               (", ".join(filterList)))
 
        # Retrieve all the fluxField names
        self._fluxFields = []
        for filterName in filterList:
            fluxField = None
 
            refFilterName = self.config.filterMap.get(filterName)
 
            if refFilterName is not None:
                try:
                    fluxField = getRefFluxField(results.refCat.schema, filterName=refFilterName)
                except RuntimeError:
                    # This flux field isn't available.  Set to None
                    fluxField = None
 
            if fluxField is None:
                self.log.warning(f'No reference flux field for camera filter {filterName}')
 
            self._fluxFields.append(fluxField)

◆ getFgcmReferenceStarsHealpix()

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.getFgcmReferenceStarsHealpix	(	self,
		nside,
		pixel,
		filterList,
		nest = False )

Get a reference catalog that overlaps a healpix pixel, using multiple
filters.  In addition, apply colorterms if available.

Return format is a numpy recarray for use with fgcm, with the format:

dtype = ([('ra', `np.float64`),
          ('dec', `np.float64`),
          ('refMag', `np.float32`, len(filterList)),
          ('refMagErr', `np.float32`, len(filterList)])

Reference magnitudes (AB) will be 99 for non-detections.

Parameters
----------
nside: `int`
   Healpix nside of pixel to load
pixel: `int`
   Healpix pixel of pixel to load
filterList: `list`
   list of `str` of camera filter names.
nest: `bool`, optional
   Is the pixel in nest format?  Default is False.

Returns
-------
fgcmRefCat: `np.recarray`

Definition at line 110 of file fgcmLoadReferenceCatalog.py.

    def getFgcmReferenceStarsHealpix(self, nside, pixel, filterList, nest=False):
        """
        Get a reference catalog that overlaps a healpix pixel, using multiple
        filters.  In addition, apply colorterms if available.
 
        Return format is a numpy recarray for use with fgcm, with the format:
 
        dtype = ([('ra', `np.float64`),
                  ('dec', `np.float64`),
                  ('refMag', `np.float32`, len(filterList)),
                  ('refMagErr', `np.float32`, len(filterList)])
 
        Reference magnitudes (AB) will be 99 for non-detections.
 
        Parameters
        ----------
        nside: `int`
           Healpix nside of pixel to load
        pixel: `int`
           Healpix pixel of pixel to load
        filterList: `list`
           list of `str` of camera filter names.
        nest: `bool`, optional
           Is the pixel in nest format?  Default is False.
 
        Returns
        -------
        fgcmRefCat: `np.recarray`
        """
 
        # Determine the size of the sky circle to load
        lon, lat = hpg.pixel_to_angle(nside, pixel, nest=nest, degrees=False)
        center = lsst.geom.SpherePoint(lon * lsst.geom.radians, lat * lsst.geom.radians)
 
        theta_phi = hpg.boundaries(nside, pixel, step=1, nest=nest, lonlat=False)
 
        radius = 0.0 * lsst.geom.radians
        for ctheta, cphi in zip(*theta_phi):
            rad = center.separation(lsst.geom.SpherePoint(cphi * lsst.geom.radians,
                                                          (np.pi/2. - ctheta) * lsst.geom.radians))
            if (rad > radius):
                radius = rad
 
        # Load the fgcm-format reference catalog
        fgcmRefCat = self.getFgcmReferenceStarsSkyCircle(center.getRa().asDegrees(),
                                                         center.getDec().asDegrees(),
                                                         radius.asDegrees(),
                                                         filterList)
        catPix = hpg.angle_to_pixel(nside, fgcmRefCat['ra'], fgcmRefCat['dec'], nest=nest)
 
        inPix, = np.where(catPix == pixel)
 
        return fgcmRefCat[inPix]
 

◆ getFgcmReferenceStarsSkyCircle()

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.getFgcmReferenceStarsSkyCircle	(	self,
		ra,
		dec,
		radius,
		filterList )

Get a reference catalog that overlaps a circular sky region, using
multiple filters.  In addition, apply colorterms if available.

Return format is a numpy recarray for use with fgcm.

dtype = ([('ra', `np.float64`),
          ('dec', `np.float64`),
          ('refMag', `np.float32`, len(filterList)),
          ('refMagErr', `np.float32`, len(filterList)])

Reference magnitudes (AB) will be 99 for non-detections.

Parameters
----------
ra: `float`
   ICRS right ascension, degrees.
dec: `float`
   ICRS declination, degrees.
radius: `float`
   Radius to search, degrees.
filterList: `list`
   list of `str` of camera filter names.

Returns
-------
fgcmRefCat: `np.recarray`

Definition at line 164 of file fgcmLoadReferenceCatalog.py.

    def getFgcmReferenceStarsSkyCircle(self, ra, dec, radius, filterList):
        """
        Get a reference catalog that overlaps a circular sky region, using
        multiple filters.  In addition, apply colorterms if available.
 
        Return format is a numpy recarray for use with fgcm.
 
        dtype = ([('ra', `np.float64`),
                  ('dec', `np.float64`),
                  ('refMag', `np.float32`, len(filterList)),
                  ('refMagErr', `np.float32`, len(filterList)])
 
        Reference magnitudes (AB) will be 99 for non-detections.
 
        Parameters
        ----------
        ra: `float`
           ICRS right ascension, degrees.
        dec: `float`
           ICRS declination, degrees.
        radius: `float`
           Radius to search, degrees.
        filterList: `list`
           list of `str` of camera filter names.
 
        Returns
        -------
        fgcmRefCat: `np.recarray`
        """
 
        center = lsst.geom.SpherePoint(ra * lsst.geom.degrees, dec * lsst.geom.degrees)
 
        # Check if we haev previously cached values for the fluxFields
        if self._fluxFilters is None or self._fluxFilters != filterList:
            self._determine_flux_fields(center, filterList)
 
        skyCircle = self.refObjLoader.loadSkyCircle(center,
                                                    radius * lsst.geom.degrees,
                                                    self._referenceFilter)
 
        if not skyCircle.refCat.isContiguous():
            refCat = skyCircle.refCat.copy(deep=True)
        else:
            refCat = skyCircle.refCat
 
        # Select on raw (uncorrected) catalog, where the errors should make more sense
        goodSources = self.referenceSelector.selectSources(refCat)
        selected = goodSources.selected
 
        fgcmRefCat = np.zeros(np.sum(selected), dtype=[('ra', 'f8'),
                                                       ('dec', 'f8'),
                                                       ('refMag', 'f4', len(filterList)),
                                                       ('refMagErr', 'f4', len(filterList))])
        if fgcmRefCat.size == 0:
            # Return an empty catalog if we don't have any selected sources
            return fgcmRefCat
 
        # The ra/dec native Angle format is radians
        # We determine the conversion from the native units (typically
        # radians) to degrees for the first observation.  This allows us
        # to treate ra/dec as numpy arrays rather than Angles, which would
        # be approximately 600x slower.
 
        conv = refCat[0]['coord_ra'].asDegrees() / float(refCat[0]['coord_ra'])
        fgcmRefCat['ra'] = refCat['coord_ra'][selected] * conv
        fgcmRefCat['dec'] = refCat['coord_dec'][selected] * conv
 
        # Default (unset) values are 99.0
        fgcmRefCat['refMag'][:, :] = 99.0
        fgcmRefCat['refMagErr'][:, :] = 99.0
 
        if self.config.applyColorTerms:
            for i, (filterName, fluxField) in enumerate(zip(self._fluxFilters, self._fluxFields)):
                if fluxField is None:
                    continue
 
                self.log.debug("Applying color terms for filtername=%r" % (filterName))
 
                colorterm = self.config.colorterms.getColorterm(filterName, self.refCatName, doRaise=True)
 
                refMag, refMagErr = colorterm.getCorrectedMagnitudes(refCat)
 
                # nan_to_num replaces nans with zeros, and this ensures that we select
                # magnitudes that both filter out nans and are not very large (corresponding
                # to very small fluxes), as "99" is a common sentinel for illegal magnitudes.
 
                good, = np.where((np.nan_to_num(refMag[selected]) < 90.0)
                                 & (np.nan_to_num(refMagErr[selected]) < 90.0)
                                 & (np.nan_to_num(refMagErr[selected]) > 0.0))
 
                fgcmRefCat['refMag'][good, i] = refMag[selected][good]
                fgcmRefCat['refMagErr'][good, i] = refMagErr[selected][good]
 
        else:
            # No colorterms
 
            for i, (filterName, fluxField) in enumerate(zip(self._fluxFilters, self._fluxFields)):
                # nan_to_num replaces nans with zeros, and this ensures that we select
                # fluxes that both filter out nans and are positive.
                good, = np.where((np.nan_to_num(refCat[fluxField][selected]) > 0.0)
                                 & (np.nan_to_num(refCat[fluxField+'Err'][selected]) > 0.0))
                refMag = (refCat[fluxField][selected][good] * units.nJy).to_value(units.ABmag)
                refMagErr = abMagErrFromFluxErr(refCat[fluxField+'Err'][selected][good],
                                                refCat[fluxField][selected][good])
                fgcmRefCat['refMag'][good, i] = refMag
                fgcmRefCat['refMagErr'][good, i] = refMagErr
 
        return fgcmRefCat
 

Member Data Documentation

◆ _DefaultName

str lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask._DefaultName = 'fgcmLoadReferenceCatalog'

staticprotected

Definition at line 93 of file fgcmLoadReferenceCatalog.py.

◆ _fluxFields

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask._fluxFields

protected

Definition at line 107 of file fgcmLoadReferenceCatalog.py.

◆ _fluxFilters

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask._fluxFilters

protected

Definition at line 106 of file fgcmLoadReferenceCatalog.py.

◆ _referenceFilter

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask._referenceFilter

protected

Definition at line 108 of file fgcmLoadReferenceCatalog.py.

◆ ConfigClass

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.ConfigClass = FgcmLoadReferenceCatalogConfig

static

Definition at line 92 of file fgcmLoadReferenceCatalog.py.

◆ refCatName

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.refCatName

Definition at line 100 of file fgcmLoadReferenceCatalog.py.

◆ refObjLoader

lsst.fgcmcal.fgcmLoadReferenceCatalog.FgcmLoadReferenceCatalogTask.refObjLoader

Definition at line 99 of file fgcmLoadReferenceCatalog.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/fgcmcal/g487adcacf7+5fae3daba8/python/lsst/fgcmcal/fgcmLoadReferenceCatalog.py

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _determine_flux_fields()

◆ getFgcmReferenceStarsHealpix()

◆ getFgcmReferenceStarsSkyCircle()

Member Data Documentation

◆ _DefaultName

◆ _fluxFields

◆ _fluxFilters

◆ _referenceFilter

◆ ConfigClass

◆ refCatName

◆ refObjLoader

◆ init()