Inheritance diagram for lsst.meas.astrom.astrometry.AstrometryTask:

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

def	run (self, sourceCat, exposure)

def	solve (self, exposure, sourceCat)

def	setRefObjLoader (self, refObjLoader)

def	loadAndMatch (self, exposure, sourceCat)

Public Attributes
	usedKey

	refObjLoader

Static Public Attributes
	ConfigClass = AstrometryConfig

Detailed Description

Match an input source catalog with objects from a reference catalog and
solve for the WCS.

This task is broken into two main subasks: matching and WCS fitting which
are very interactive. The matching here can be considered in part a first
pass WCS fitter due to the fitter's sensitivity to outliers.

Parameters
----------
refObjLoader : `lsst.meas.algorithms.ReferenceLoader`
    A reference object loader object
schema : `lsst.afw.table.Schema`
    Used to set "calib_astrometry_used" flag in output source catalog.
**kwargs
    additional keyword arguments for pipe_base
    `lsst.pipe.base.Task.__init__`

Definition at line 89 of file astrometry.py.

Constructor & Destructor Documentation

◆ init()

def lsst.meas.astrom.astrometry.AstrometryTask.__init__	(		self,
			refObjLoader,
			schema = `None`,
		**	kwargs
	)

Definition at line 110 of file astrometry.py.

     def __init__(self, refObjLoader, schema=None, **kwargs):
         RefMatchTask.__init__(self, refObjLoader, **kwargs)
  
         if schema is not None:
             self.usedKey = schema.addField("calib_astrometry_used", type="Flag",
                                            doc="set if source was used in astrometric calibration")
         else:
             self.usedKey = None
  
         self.makeSubtask("wcsFitter")
  

Member Function Documentation

◆ loadAndMatch()

def lsst.meas.astrom.ref_match.RefMatchTask.loadAndMatch	(	self,
		exposure,
		sourceCat
	)

inherited

Load reference objects overlapping an exposure and match to sources
detected on that exposure.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    exposure that the sources overlap
sourceCat : `lsst.afw.table.SourceCatalog.`
    catalog of sources detected on the exposure

Returns
-------
result : `lsst.pipe.base.Struct`
    Result struct with Components:

    - ``refCat`` : reference object catalog of objects that overlap the
      exposure (`lsst.afw.table.SimpleCatalog`)
    - ``matches`` :  Matched sources and references
      (`list` of `lsst.afw.table.ReferenceMatch`)
    - ``matchMeta`` : metadata needed to unpersist matches
      (`lsst.daf.base.PropertyList`)

Notes
-----
ignores config.matchDistanceSigma

Definition at line 116 of file ref_match.py.

     def loadAndMatch(self, exposure, sourceCat):
         """Load reference objects overlapping an exposure and match to sources
         detected on that exposure.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.Exposure`
             exposure that the sources overlap
         sourceCat : `lsst.afw.table.SourceCatalog.`
             catalog of sources detected on the exposure
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Result struct with Components:
  
             - ``refCat`` : reference object catalog of objects that overlap the
               exposure (`lsst.afw.table.SimpleCatalog`)
             - ``matches`` :  Matched sources and references
               (`list` of `lsst.afw.table.ReferenceMatch`)
             - ``matchMeta`` : metadata needed to unpersist matches
               (`lsst.daf.base.PropertyList`)
  
         Notes
         -----
         ignores config.matchDistanceSigma
         """
         if self.refObjLoader is None:
             raise RuntimeError("Running matcher task with no refObjLoader set in __ini__ or setRefObjLoader")
         import lsstDebug
         debug = lsstDebug.Info(__name__)
  
         expMd = self._getExposureMetadata(exposure)
  
         sourceSelection = self.sourceSelector.run(sourceCat)
  
         sourceFluxField = "slot_%sFlux_instFlux" % (self.config.sourceFluxType)
  
         loadRes = self.refObjLoader.loadPixelBox(
             bbox=expMd.bbox,
             wcs=expMd.wcs,
             filterName=expMd.filterName,
             photoCalib=expMd.photoCalib,
             epoch=expMd.epoch,
         )
  
         refSelection = self.referenceSelector.run(loadRes.refCat)
  
         matchMeta = self.refObjLoader.getMetadataBox(
             bbox=expMd.bbox,
             wcs=expMd.wcs,
             filterName=expMd.filterName,
             photoCalib=expMd.photoCalib,
             epoch=expMd.epoch,
         )
  
         matchRes = self.matcher.matchObjectsToSources(
             refCat=refSelection.sourceCat,
             sourceCat=sourceSelection.sourceCat,
             wcs=expMd.wcs,
             sourceFluxField=sourceFluxField,
             refFluxField=loadRes.fluxField,
             match_tolerance=None,
         )
  
         distStats = self._computeMatchStatsOnSky(matchRes.matches)
         self.log.info(
             "Found %d matches with scatter = %0.3f +- %0.3f arcsec; " %
             (len(matchRes.matches), distStats.distMean.asArcseconds(), distStats.distStdDev.asArcseconds())
         )
  
         if debug.display:
             frame = int(debug.frame)
             displayAstrometry(
                 refCat=refSelection.sourceCat,
                 sourceCat=sourceSelection.sourceCat,
                 matches=matchRes.matches,
                 exposure=exposure,
                 bbox=expMd.bbox,
                 frame=frame,
                 title="Matches",
             )
  
         return pipeBase.Struct(
             refCat=loadRes.refCat,
             refSelection=refSelection,
             sourceSelection=sourceSelection,
             matches=matchRes.matches,
             matchMeta=matchMeta,
         )
  

◆ run()

def lsst.meas.astrom.astrometry.AstrometryTask.run	(	self,
		sourceCat,
		exposure
	)

Load reference objects, match sources and optionally fit a WCS.

This is a thin layer around solve or loadAndMatch, depending on
config.forceKnownWcs.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    exposure whose WCS is to be fit
    The following are read only:

    - bbox
    - photoCalib (may be absent)
    - filter (may be unset)
    - detector (if wcs is pure tangent; may be absent)

    The following are updated:

    - wcs (the initial value is used as an initial guess, and is
      required)

sourceCat : `lsst.afw.table.SourceCatalog`
    catalog of sources detected on the exposure

Returns
-------
result : `lsst.pipe.base.Struct`
    with these fields:

    - ``refCat`` : reference object catalog of objects that overlap the
      exposure (with some margin) (`lsst.afw.table.SimpleCatalog`).
    - ``matches`` : astrometric matches
      (`list` of `lsst.afw.table.ReferenceMatch`).
    - ``scatterOnSky`` :  median on-sky separation between reference
      objects and sources in "matches"
      (`lsst.afw.geom.Angle`) or `None` if config.forceKnownWcs True
    - ``matchMeta`` :  metadata needed to unpersist matches
      (`lsst.daf.base.PropertyList`)

Definition at line 122 of file astrometry.py.

     def run(self, sourceCat, exposure):
         """Load reference objects, match sources and optionally fit a WCS.
  
         This is a thin layer around solve or loadAndMatch, depending on
         config.forceKnownWcs.
  
         Parameters
         ----------
         exposure : `lsst.afw.image.Exposure`
             exposure whose WCS is to be fit
             The following are read only:
  
             - bbox
             - photoCalib (may be absent)
             - filter (may be unset)
             - detector (if wcs is pure tangent; may be absent)
  
             The following are updated:
  
             - wcs (the initial value is used as an initial guess, and is
               required)
  
         sourceCat : `lsst.afw.table.SourceCatalog`
             catalog of sources detected on the exposure
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             with these fields:
  
             - ``refCat`` : reference object catalog of objects that overlap the
               exposure (with some margin) (`lsst.afw.table.SimpleCatalog`).
             - ``matches`` : astrometric matches
               (`list` of `lsst.afw.table.ReferenceMatch`).
             - ``scatterOnSky`` :  median on-sky separation between reference
               objects and sources in "matches"
               (`lsst.afw.geom.Angle`) or `None` if config.forceKnownWcs True
             - ``matchMeta`` :  metadata needed to unpersist matches
               (`lsst.daf.base.PropertyList`)
         """
         if self.refObjLoader is None:
             raise RuntimeError("Running matcher task with no refObjLoader set in __init__ or setRefObjLoader")
         if self.config.forceKnownWcs:
             res = self.loadAndMatch(exposure=exposure, sourceCat=sourceCat)
             res.scatterOnSky = None
         else:
             res = self.solve(exposure=exposure, sourceCat=sourceCat)
         return res
  

◆ setRefObjLoader()

def lsst.meas.astrom.ref_match.RefMatchTask.setRefObjLoader	(	self,
		refObjLoader
	)

inherited

Sets the reference object loader for the task

Parameters
----------
refObjLoader
    An instance of a reference object loader task or class

Definition at line 105 of file ref_match.py.

     def setRefObjLoader(self, refObjLoader):
         """Sets the reference object loader for the task
  
         Parameters
         ----------
         refObjLoader
             An instance of a reference object loader task or class
         """
         self.refObjLoader = refObjLoader
  

◆ solve()

def lsst.meas.astrom.astrometry.AstrometryTask.solve	(	self,
		exposure,
		sourceCat
	)

Load reference objects overlapping an exposure, match to sources and
fit a WCS

Returns
-------
result : `lsst.pipe.base.Struct`
    Result struct with components:

    - ``refCat`` : reference object catalog of objects that overlap the
      exposure (with some margin) (`lsst::afw::table::SimpleCatalog`).
    - ``matches`` :  astrometric matches
      (`list` of `lsst.afw.table.ReferenceMatch`).
    - ``scatterOnSky`` :  median on-sky separation between reference
      objects and sources in "matches" (`lsst.geom.Angle`)
    - ``matchMeta`` :  metadata needed to unpersist matches
      (`lsst.daf.base.PropertyList`)

Notes
-----
ignores config.forceKnownWcs

Definition at line 172 of file astrometry.py.

     def solve(self, exposure, sourceCat):
         """Load reference objects overlapping an exposure, match to sources and
         fit a WCS
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Result struct with components:
  
             - ``refCat`` : reference object catalog of objects that overlap the
               exposure (with some margin) (`lsst::afw::table::SimpleCatalog`).
             - ``matches`` :  astrometric matches
               (`list` of `lsst.afw.table.ReferenceMatch`).
             - ``scatterOnSky`` :  median on-sky separation between reference
               objects and sources in "matches" (`lsst.geom.Angle`)
             - ``matchMeta`` :  metadata needed to unpersist matches
               (`lsst.daf.base.PropertyList`)
  
         Notes
         -----
         ignores config.forceKnownWcs
         """
         if self.refObjLoader is None:
             raise RuntimeError("Running matcher task with no refObjLoader set in __init__ or setRefObjLoader")
         import lsstDebug
         debug = lsstDebug.Info(__name__)
  
         expMd = self._getExposureMetadata(exposure)
  
         sourceSelection = self.sourceSelector.run(sourceCat)
  
         self.log.info("Purged %d sources, leaving %d good sources" %
                       (len(sourceCat) - len(sourceSelection.sourceCat),
                        len(sourceSelection.sourceCat)))
  
         loadRes = self.refObjLoader.loadPixelBox(
             bbox=expMd.bbox,
             wcs=expMd.wcs,
             filterName=expMd.filterName,
             photoCalib=expMd.photoCalib,
             epoch=expMd.epoch,
         )
  
         refSelection = self.referenceSelector.run(loadRes.refCat)
  
         matchMeta = self.refObjLoader.getMetadataBox(
             bbox=expMd.bbox,
             wcs=expMd.wcs,
             filterName=expMd.filterName,
             photoCalib=expMd.photoCalib,
             epoch=expMd.epoch,
         )
  
         if debug.display:
             frame = int(debug.frame)
             displayAstrometry(
                 refCat=refSelection.sourceCat,
                 sourceCat=sourceSelection.sourceCat,
                 exposure=exposure,
                 bbox=expMd.bbox,
                 frame=frame,
                 title="Reference catalog",
             )
  
         res = None
         wcs = expMd.wcs
         match_tolerance = None
         for i in range(self.config.maxIter):
             iterNum = i + 1
             try:
                 tryRes = self._matchAndFitWcs(
                     refCat=refSelection.sourceCat,
                     sourceCat=sourceCat,
                     goodSourceCat=sourceSelection.sourceCat,
                     refFluxField=loadRes.fluxField,
                     bbox=expMd.bbox,
                     wcs=wcs,
                     exposure=exposure,
                     match_tolerance=match_tolerance,
                 )
             except Exception as e:
                 # if we have had a succeessful iteration then use that; otherwise fail
                 if i > 0:
                     self.log.info("Fit WCS iter %d failed; using previous iteration: %s" % (iterNum, e))
                     iterNum -= 1
                     break
                 else:
                     raise
  
             match_tolerance = tryRes.match_tolerance
             tryMatchDist = self._computeMatchStatsOnSky(tryRes.matches)
             self.log.debug(
                 "Match and fit WCS iteration %d: found %d matches with scatter = %0.3f +- %0.3f arcsec; "
                 "max match distance = %0.3f arcsec",
                 iterNum, len(tryRes.matches), tryMatchDist.distMean.asArcseconds(),
                 tryMatchDist.distStdDev.asArcseconds(), tryMatchDist.maxMatchDist.asArcseconds())
  
             maxMatchDist = tryMatchDist.maxMatchDist
             res = tryRes
             wcs = res.wcs
             if maxMatchDist.asArcseconds() < self.config.minMatchDistanceArcSec:
                 self.log.debug(
                     "Max match distance = %0.3f arcsec < %0.3f = config.minMatchDistanceArcSec; "
                     "that's good enough",
                     maxMatchDist.asArcseconds(), self.config.minMatchDistanceArcSec)
                 break
             match_tolerance.maxMatchDist = maxMatchDist
  
         self.log.info(
             "Matched and fit WCS in %d iterations; "
             "found %d matches with scatter = %0.3f +- %0.3f arcsec" %
             (iterNum, len(tryRes.matches), tryMatchDist.distMean.asArcseconds(),
                 tryMatchDist.distStdDev.asArcseconds()))
         for m in res.matches:
             if self.usedKey:
                 m.second.set(self.usedKey, True)
         exposure.setWcs(res.wcs)
  
         # Record the scatter in the exposure metadata
         md = exposure.getMetadata()
         md['SFM_ASTROM_OFFSET_MEAN'] = tryMatchDist.distMean.asArcseconds()
         md['SFM_ASTROM_OFFSET_STD'] = tryMatchDist.distStdDev.asArcseconds()
  
         return pipeBase.Struct(
             refCat=refSelection.sourceCat,
             matches=res.matches,
             scatterOnSky=res.scatterOnSky,
             matchMeta=matchMeta,
         )
  

Member Data Documentation

◆ ConfigClass

lsst.meas.astrom.astrometry.AstrometryTask.ConfigClass = AstrometryConfig

static

Definition at line 107 of file astrometry.py.

◆ refObjLoader

lsst.meas.astrom.ref_match.RefMatchTask.refObjLoader

inherited

Definition at line 92 of file ref_match.py.

◆ usedKey

lsst.meas.astrom.astrometry.AstrometryTask.usedKey

Definition at line 114 of file astrometry.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/meas_astrom/22.0.1-4-g8623105+b8044ec9de/python/lsst/meas/astrom/astrometry.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ loadAndMatch()

◆ run()

◆ setRefObjLoader()

◆ solve()

Member Data Documentation

◆ ConfigClass

◆ refObjLoader

◆ usedKey

◆ init()