Inheritance diagram for lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask:

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

def	runQuantum (self, butlerQC, inputRefs, outputRefs)

def	fgcmMakeAllStarObservations (self, groupedDataRefs, visitCat, sourceSchema, camera, calibFluxApertureRadius=None, visitCatDataRef=None, starObsDataRef=None, inStarObsCat=None)

def	runDataRef (self, butler, dataRefs)

def	fgcmMakeVisitCatalog (self, camera, groupedDataRefs, bkgDataRefDict=None, visitCatDataRef=None, inVisitCat=None)

def	fgcmMatchStars (self, visitCat, obsCat, lutDataRef=None)

Public Attributes
	sourceSchema

Static Public Attributes
	ConfigClass = FgcmBuildStarsTableConfig

	RunnerClass = FgcmBuildStarsRunner

bool	canMultiprocess = False

Detailed Description

Build stars for the FGCM global calibration, using sourceTable_visit catalogs.

Definition at line 215 of file fgcmBuildStarsTable.py.

Constructor & Destructor Documentation

◆ init()

def lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.__init__	(		self,
			initInputs = `None`,
		**	kwargs
	)

Definition at line 225 of file fgcmBuildStarsTable.py.

     def __init__(self, initInputs=None, **kwargs):
         super().__init__(initInputs=initInputs, **kwargs)
         if initInputs is not None:
             self.sourceSchema = initInputs["sourceSchema"].schema
  

Member Function Documentation

◆ fgcmMakeAllStarObservations()

def lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.fgcmMakeAllStarObservations	(	self,
		groupedDataRefs,
		visitCat,
		sourceSchema,
		camera,
		calibFluxApertureRadius = `None`,
		visitCatDataRef = `None`,
		starObsDataRef = `None`,
		inStarObsCat = `None`
	)

Compile all good star observations from visits in visitCat.  Checkpoint files
will be stored if both visitCatDataRef and starObsDataRef are not None.

Parameters
----------
groupedDataRefs : `dict` of `list`s
    Lists of `~lsst.daf.persistence.ButlerDataRef` or
    `~lsst.daf.butler.DeferredDatasetHandle`, grouped by visit.
visitCat : `~afw.table.BaseCatalog`
    Catalog with visit data for FGCM
sourceSchema : `~lsst.afw.table.Schema`
    Schema for the input src catalogs.
camera : `~lsst.afw.cameraGeom.Camera`
calibFluxApertureRadius : `float`, optional
    Aperture radius for calibration flux.
visitCatDataRef : `~lsst.daf.persistence.ButlerDataRef`, optional
    Dataref to write visitCat for checkpoints
starObsDataRef : `~lsst.daf.persistence.ButlerDataRef`, optional
    Dataref to write the star observation catalog for checkpoints.
inStarObsCat : `~afw.table.BaseCatalog`
    Input observation catalog.  If this is incomplete, observations
    will be appended from when it was cut off.

Returns
-------
fgcmStarObservations : `afw.table.BaseCatalog`
    Full catalog of good observations.

Raises
------
RuntimeError: Raised if doSubtractLocalBackground is True and
   calibFluxApertureRadius is not set.

Reimplemented from lsst.fgcmcal.fgcmBuildStarsBase.FgcmBuildStarsBaseTask.

Definition at line 394 of file fgcmBuildStarsTable.py.

                                     inStarObsCat=None):
         startTime = time.time()
  
         # If both dataRefs are None, then we assume the caller does not
         # want to store checkpoint files.  If both are set, we will
         # do checkpoint files.  And if only one is set, this is potentially
         # unintentional and we will warn.
         if (visitCatDataRef is not None and starObsDataRef is None
            or visitCatDataRef is None and starObsDataRef is not None):
             self.log.warning("Only one of visitCatDataRef and starObsDataRef are set, so "
                              "no checkpoint files will be persisted.")
  
         if self.config.doSubtractLocalBackground and calibFluxApertureRadius is None:
             raise RuntimeError("Must set calibFluxApertureRadius if doSubtractLocalBackground is True.")
  
         # To get the correct output schema, we use similar code as fgcmBuildStarsTask
         # We are not actually using this mapper, except to grab the outputSchema
         sourceMapper = self._makeSourceMapper(sourceSchema)
         outputSchema = sourceMapper.getOutputSchema()
  
         # Construct mapping from ccd number to index
         ccdMapping = {}
         for ccdIndex, detector in enumerate(camera):
             ccdMapping[detector.getId()] = ccdIndex
  
         approxPixelAreaFields = computeApproxPixelAreaFields(camera)
  
         if inStarObsCat is not None:
             fullCatalog = inStarObsCat
             comp1 = fullCatalog.schema.compare(outputSchema, outputSchema.EQUAL_KEYS)
             comp2 = fullCatalog.schema.compare(outputSchema, outputSchema.EQUAL_NAMES)
             if not comp1 or not comp2:
                 raise RuntimeError("Existing fgcmStarObservations file found with mismatched schema.")
         else:
             fullCatalog = afwTable.BaseCatalog(outputSchema)
  
         visitKey = outputSchema['visit'].asKey()
         ccdKey = outputSchema['ccd'].asKey()
         instMagKey = outputSchema['instMag'].asKey()
         instMagErrKey = outputSchema['instMagErr'].asKey()
  
         # Prepare local background if desired
         if self.config.doSubtractLocalBackground:
             localBackgroundArea = np.pi*calibFluxApertureRadius**2.
  
         columns = None
  
         k = 2.5/np.log(10.)
  
         for counter, visit in enumerate(visitCat):
             # Check if these sources have already been read and stored in the checkpoint file
             if visit['sources_read']:
                 continue
  
             expTime = visit['exptime']
  
             dataRef = groupedDataRefs[visit['visit']][-1]
  
             if isinstance(dataRef, dafPersist.ButlerDataRef):
                 srcTable = dataRef.get()
                 if columns is None:
                     columns, detColumn = self._get_sourceTable_visit_columns(srcTable.columns)
                 df = srcTable.toDataFrame(columns)
             else:
                 if columns is None:
                     inColumns = dataRef.get(component='columns')
                     columns, detColumn = self._get_sourceTable_visit_columns(inColumns)
                 df = dataRef.get(parameters={'columns': columns})
  
             goodSrc = self.sourceSelector.selectSources(df)
  
             # Need to add a selection based on the local background correction
             # if necessary
             if self.config.doSubtractLocalBackground:
                 localBackground = localBackgroundArea*df[self.config.localBackgroundFluxField].values
                 use, = np.where((goodSrc.selected)
                                 & ((df[self.config.instFluxField].values - localBackground) > 0.0))
             else:
                 use, = np.where(goodSrc.selected)
  
             tempCat = afwTable.BaseCatalog(fullCatalog.schema)
             tempCat.resize(use.size)
  
             tempCat['ra'][:] = np.deg2rad(df['ra'].values[use])
             tempCat['dec'][:] = np.deg2rad(df['decl'].values[use])
             tempCat['x'][:] = df['x'].values[use]
             tempCat['y'][:] = df['y'].values[use]
             # The "visit" name in the parquet table is hard-coded.
             tempCat[visitKey][:] = df['visit'].values[use]
             tempCat[ccdKey][:] = df[detColumn].values[use]
             tempCat['psf_candidate'] = df[self.config.psfCandidateName].values[use]
  
             if self.config.doSubtractLocalBackground:
                 # At the moment we only adjust the flux and not the flux
                 # error by the background because the error on
                 # base_LocalBackground_instFlux is the rms error in the
                 # background annulus, not the error on the mean in the
                 # background estimate (which is much smaller, by sqrt(n)
                 # pixels used to estimate the background, which we do not
                 # have access to in this task).  In the default settings,
                 # the annulus is sufficiently large such that these
                 # additional errors are are negligibly small (much less
                 # than a mmag in quadrature).
  
                 # This is the difference between the mag with local background correction
                 # and the mag without local background correction.
                 tempCat['deltaMagBkg'] = (-2.5*np.log10(df[self.config.instFluxField].values[use]
                                                         - localBackground[use]) -
                                           -2.5*np.log10(df[self.config.instFluxField].values[use]))
             else:
                 tempCat['deltaMagBkg'][:] = 0.0
  
             # Need to loop over ccds here
             for detector in camera:
                 ccdId = detector.getId()
                 # used index for all observations with a given ccd
                 use2 = (tempCat[ccdKey] == ccdId)
                 tempCat['jacobian'][use2] = approxPixelAreaFields[ccdId].evaluate(tempCat['x'][use2],
                                                                                   tempCat['y'][use2])
                 scaledInstFlux = (df[self.config.instFluxField].values[use[use2]]
                                   * visit['scaling'][ccdMapping[ccdId]])
                 tempCat[instMagKey][use2] = (-2.5*np.log10(scaledInstFlux) + 2.5*np.log10(expTime))
  
             # Compute instMagErr from instFluxErr/instFlux, any scaling
             # will cancel out.
             tempCat[instMagErrKey][:] = k*(df[self.config.instFluxField + 'Err'].values[use]
                                            / df[self.config.instFluxField].values[use])
  
             # Apply the jacobian if configured
             if self.config.doApplyWcsJacobian:
                 tempCat[instMagKey][:] -= 2.5*np.log10(tempCat['jacobian'][:])
  
             fullCatalog.extend(tempCat)
  
             # Now do the aperture information
             with np.warnings.catch_warnings():
                 # Ignore warnings, we will filter infinites and nans below
                 np.warnings.simplefilter("ignore")
  
                 instMagIn = -2.5*np.log10(df[self.config.apertureInnerInstFluxField].values[use])
                 instMagErrIn = k*(df[self.config.apertureInnerInstFluxField + 'Err'].values[use]
                                   / df[self.config.apertureInnerInstFluxField].values[use])
                 instMagOut = -2.5*np.log10(df[self.config.apertureOuterInstFluxField].values[use])
                 instMagErrOut = k*(df[self.config.apertureOuterInstFluxField + 'Err'].values[use]
                                    / df[self.config.apertureOuterInstFluxField].values[use])
  
             ok = (np.isfinite(instMagIn) & np.isfinite(instMagErrIn)
                   & np.isfinite(instMagOut) & np.isfinite(instMagErrOut))
  
             visit['deltaAper'] = np.median(instMagIn[ok] - instMagOut[ok])
             visit['sources_read'] = True
  
             self.log.info("  Found %d good stars in visit %d (deltaAper = %0.3f)",
                           use.size, visit['visit'], visit['deltaAper'])
  
             if ((counter % self.config.nVisitsPerCheckpoint) == 0
                and starObsDataRef is not None and visitCatDataRef is not None):
                 # We need to persist both the stars and the visit catalog which gets
                 # additional metadata from each visit.
                 starObsDataRef.put(fullCatalog)
                 visitCatDataRef.put(visitCat)
  
         self.log.info("Found all good star observations in %.2f s" %
                       (time.time() - startTime))
  
         return fullCatalog
  

◆ fgcmMakeVisitCatalog()

def lsst.fgcmcal.fgcmBuildStarsBase.FgcmBuildStarsBaseTask.fgcmMakeVisitCatalog	(	self,
		camera,
		groupedDataRefs,
		bkgDataRefDict = `None`,
		visitCatDataRef = `None`,
		inVisitCat = `None`
	)

inherited

Make a visit catalog with all the keys from each visit

Parameters
----------
camera: `lsst.afw.cameraGeom.Camera`
   Camera from the butler
groupedDataRefs: `dict`
   Dictionary with visit keys, and `list`s of
   `lsst.daf.persistence.ButlerDataRef`
bkgDataRefDict: `dict`, optional
   Dictionary of gen3 dataRefHandles for background info.
visitCatDataRef: `lsst.daf.persistence.ButlerDataRef`, optional
   Dataref to write visitCat for checkpoints
inVisitCat: `afw.table.BaseCatalog`, optional
   Input (possibly incomplete) visit catalog

Returns
-------
visitCat: `afw.table.BaseCatalog`

Definition at line 459 of file fgcmBuildStarsBase.py.

                              visitCatDataRef=None, inVisitCat=None):
         """
         Make a visit catalog with all the keys from each visit
  
         Parameters
         ----------
         camera: `lsst.afw.cameraGeom.Camera`
            Camera from the butler
         groupedDataRefs: `dict`
            Dictionary with visit keys, and `list`s of
            `lsst.daf.persistence.ButlerDataRef`
         bkgDataRefDict: `dict`, optional
            Dictionary of gen3 dataRefHandles for background info.
         visitCatDataRef: `lsst.daf.persistence.ButlerDataRef`, optional
            Dataref to write visitCat for checkpoints
         inVisitCat: `afw.table.BaseCatalog`, optional
            Input (possibly incomplete) visit catalog
  
         Returns
         -------
         visitCat: `afw.table.BaseCatalog`
         """
  
         self.log.info("Assembling visitCatalog from %d %ss" %
                       (len(groupedDataRefs), self.config.visitDataRefName))
  
         nCcd = len(camera)
  
         if inVisitCat is None:
             schema = self._makeFgcmVisitSchema(nCcd)
  
             visitCat = afwTable.BaseCatalog(schema)
             visitCat.reserve(len(groupedDataRefs))
             visitCat.resize(len(groupedDataRefs))
  
             visitCat['visit'] = list(groupedDataRefs.keys())
             visitCat['used'] = 0
             visitCat['sources_read'] = False
         else:
             visitCat = inVisitCat
  
         # No matter what, fill the catalog. This will check if it was
         # already read.
         self._fillVisitCatalog(visitCat, groupedDataRefs,
                                bkgDataRefDict=bkgDataRefDict,
                                visitCatDataRef=visitCatDataRef)
  
         return visitCat
  

◆ fgcmMatchStars()

def lsst.fgcmcal.fgcmBuildStarsBase.FgcmBuildStarsBaseTask.fgcmMatchStars	(	self,
		visitCat,
		obsCat,
		lutDataRef = `None`
	)

inherited

Use FGCM code to match observations into unique stars.

Parameters
----------
visitCat: `afw.table.BaseCatalog`
   Catalog with visit data for fgcm
obsCat: `afw.table.BaseCatalog`
   Full catalog of star observations for fgcm
lutDataRef: `lsst.daf.persistence.ButlerDataRef` or
            `lsst.daf.butler.DeferredDatasetHandle`, optional
   Data reference to fgcm look-up table (used if matching reference stars).

Returns
-------
fgcmStarIdCat: `afw.table.BaseCatalog`
   Catalog of unique star identifiers and index keys
fgcmStarIndicesCat: `afwTable.BaseCatalog`
   Catalog of unique star indices
fgcmRefCat: `afw.table.BaseCatalog`
   Catalog of matched reference stars.
   Will be None if `config.doReferenceMatches` is False.

Definition at line 686 of file fgcmBuildStarsBase.py.

     def fgcmMatchStars(self, visitCat, obsCat, lutDataRef=None):
         """
         Use FGCM code to match observations into unique stars.
  
         Parameters
         ----------
         visitCat: `afw.table.BaseCatalog`
            Catalog with visit data for fgcm
         obsCat: `afw.table.BaseCatalog`
            Full catalog of star observations for fgcm
         lutDataRef: `lsst.daf.persistence.ButlerDataRef` or
                     `lsst.daf.butler.DeferredDatasetHandle`, optional
            Data reference to fgcm look-up table (used if matching reference stars).
  
         Returns
         -------
         fgcmStarIdCat: `afw.table.BaseCatalog`
            Catalog of unique star identifiers and index keys
         fgcmStarIndicesCat: `afwTable.BaseCatalog`
            Catalog of unique star indices
         fgcmRefCat: `afw.table.BaseCatalog`
            Catalog of matched reference stars.
            Will be None if `config.doReferenceMatches` is False.
         """
         # get filter names into a numpy array...
         # This is the type that is expected by the fgcm code
         visitFilterNames = np.zeros(len(visitCat), dtype='a30')
         for i in range(len(visitCat)):
             visitFilterNames[i] = visitCat[i]['physicalFilter']
  
         # match to put filterNames with observations
         visitIndex = np.searchsorted(visitCat['visit'],
                                      obsCat['visit'])
  
         obsFilterNames = visitFilterNames[visitIndex]
  
         if self.config.doReferenceMatches:
             # Get the reference filter names, using the LUT
             lutCat = lutDataRef.get()
  
             stdFilterDict = {filterName: stdFilter for (filterName, stdFilter) in
                              zip(lutCat[0]['physicalFilters'].split(','),
                                  lutCat[0]['stdPhysicalFilters'].split(','))}
             stdLambdaDict = {stdFilter: stdLambda for (stdFilter, stdLambda) in
                              zip(lutCat[0]['stdPhysicalFilters'].split(','),
                                  lutCat[0]['lambdaStdFilter'])}
  
             del lutCat
  
             referenceFilterNames = self._getReferenceFilterNames(visitCat,
                                                                  stdFilterDict,
                                                                  stdLambdaDict)
             self.log.info("Using the following reference filters: %s" %
                           (', '.join(referenceFilterNames)))
  
         else:
             # This should be an empty list
             referenceFilterNames = []
  
         # make the fgcm starConfig dict
         starConfig = {'logger': self.log,
                       'filterToBand': self.config.physicalFilterMap,
                       'requiredBands': self.config.requiredBands,
                       'minPerBand': self.config.minPerBand,
                       'matchRadius': self.config.matchRadius,
                       'isolationRadius': self.config.isolationRadius,
                       'matchNSide': self.config.matchNside,
                       'coarseNSide': self.config.coarseNside,
                       'densNSide': self.config.densityCutNside,
                       'densMaxPerPixel': self.config.densityCutMaxPerPixel,
                       'randomSeed': self.config.randomSeed,
                       'primaryBands': self.config.primaryBands,
                       'referenceFilterNames': referenceFilterNames}
  
         # initialize the FgcmMakeStars object
         fgcmMakeStars = fgcm.FgcmMakeStars(starConfig)
  
         # make the primary stars
         # note that 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 = obsCat[0]['ra'].asDegrees() / float(obsCat[0]['ra'])
         fgcmMakeStars.makePrimaryStars(obsCat['ra'] * conv,
                                        obsCat['dec'] * conv,
                                        filterNameArray=obsFilterNames,
                                        bandSelected=False)
  
         # and match all the stars
         fgcmMakeStars.makeMatchedStars(obsCat['ra'] * conv,
                                        obsCat['dec'] * conv,
                                        obsFilterNames)
  
         if self.config.doReferenceMatches:
             fgcmMakeStars.makeReferenceMatches(self.fgcmLoadReferenceCatalog)
  
         # now persist
  
         objSchema = self._makeFgcmObjSchema()
  
         # make catalog and records
         fgcmStarIdCat = afwTable.BaseCatalog(objSchema)
         fgcmStarIdCat.reserve(fgcmMakeStars.objIndexCat.size)
         for i in range(fgcmMakeStars.objIndexCat.size):
             fgcmStarIdCat.addNew()
  
         # fill the catalog
         fgcmStarIdCat['fgcm_id'][:] = fgcmMakeStars.objIndexCat['fgcm_id']
         fgcmStarIdCat['ra'][:] = fgcmMakeStars.objIndexCat['ra']
         fgcmStarIdCat['dec'][:] = fgcmMakeStars.objIndexCat['dec']
         fgcmStarIdCat['obsArrIndex'][:] = fgcmMakeStars.objIndexCat['obsarrindex']
         fgcmStarIdCat['nObs'][:] = fgcmMakeStars.objIndexCat['nobs']
  
         obsSchema = self._makeFgcmObsSchema()
  
         fgcmStarIndicesCat = afwTable.BaseCatalog(obsSchema)
         fgcmStarIndicesCat.reserve(fgcmMakeStars.obsIndexCat.size)
         for i in range(fgcmMakeStars.obsIndexCat.size):
             fgcmStarIndicesCat.addNew()
  
         fgcmStarIndicesCat['obsIndex'][:] = fgcmMakeStars.obsIndexCat['obsindex']
  
         if self.config.doReferenceMatches:
             refSchema = self._makeFgcmRefSchema(len(referenceFilterNames))
  
             fgcmRefCat = afwTable.BaseCatalog(refSchema)
             fgcmRefCat.reserve(fgcmMakeStars.referenceCat.size)
  
             for i in range(fgcmMakeStars.referenceCat.size):
                 fgcmRefCat.addNew()
  
             fgcmRefCat['fgcm_id'][:] = fgcmMakeStars.referenceCat['fgcm_id']
             fgcmRefCat['refMag'][:, :] = fgcmMakeStars.referenceCat['refMag']
             fgcmRefCat['refMagErr'][:, :] = fgcmMakeStars.referenceCat['refMagErr']
  
             md = PropertyList()
             md.set("REFSTARS_FORMAT_VERSION", REFSTARS_FORMAT_VERSION)
             md.set("FILTERNAMES", referenceFilterNames)
             fgcmRefCat.setMetadata(md)
  
         else:
             fgcmRefCat = None
  
         return fgcmStarIdCat, fgcmStarIndicesCat, fgcmRefCat
  

◆ runDataRef()

def lsst.fgcmcal.fgcmBuildStarsBase.FgcmBuildStarsBaseTask.runDataRef	(	self,
		butler,
		dataRefs
	)

inherited

Cross-match and make star list for FGCM Input

Parameters
----------
butler:  `lsst.daf.persistence.Butler`
dataRefs: `list` of `lsst.daf.persistence.ButlerDataRef`
   Source data references for the input visits.

Raises
------
RuntimeErrror: Raised if `config.doReferenceMatches` is set and
   an fgcmLookUpTable is not available, or if computeFluxApertureRadius()
   fails if the calibFlux is not a CircularAperture flux.

Definition at line 295 of file fgcmBuildStarsBase.py.

     def runDataRef(self, butler, dataRefs):
         """
         Cross-match and make star list for FGCM Input
  
         Parameters
         ----------
         butler:  `lsst.daf.persistence.Butler`
         dataRefs: `list` of `lsst.daf.persistence.ButlerDataRef`
            Source data references for the input visits.
  
         Raises
         ------
         RuntimeErrror: Raised if `config.doReferenceMatches` is set and
            an fgcmLookUpTable is not available, or if computeFluxApertureRadius()
            fails if the calibFlux is not a CircularAperture flux.
         """
         datasetType = dataRefs[0].butlerSubset.datasetType
         self.log.info("Running with %d %s dataRefs", len(dataRefs), datasetType)
  
         if self.config.doReferenceMatches:
             self.makeSubtask("fgcmLoadReferenceCatalog", butler=butler)
             # Ensure that we have a LUT
             if not butler.datasetExists('fgcmLookUpTable'):
                 raise RuntimeError("Must have fgcmLookUpTable if using config.doReferenceMatches")
         # Compute aperture radius if necessary.  This is useful to do now before
         # any heavy lifting has happened (fail early).
         calibFluxApertureRadius = None
         if self.config.doSubtractLocalBackground:
             try:
                 calibFluxApertureRadius = computeApertureRadiusFromDataRef(dataRefs[0],
                                                                            self.config.instFluxField)
             except RuntimeError as e:
                 raise RuntimeError("Could not determine aperture radius from %s. "
                                    "Cannot use doSubtractLocalBackground." %
                                    (self.config.instFluxField)) from e
  
         camera = butler.get('camera')
         groupedDataRefs = self._findAndGroupDataRefsGen2(butler, camera, dataRefs)
  
         # Make the visit catalog if necessary
         # First check if the visit catalog is in the _current_ path
         # We cannot use Gen2 datasetExists() because that checks all parent
         # directories as well, which would make recovering from faults
         # and fgcmcal reruns impossible.
         visitCatDataRef = butler.dataRef('fgcmVisitCatalog')
         filename = visitCatDataRef.get('fgcmVisitCatalog_filename')[0]
         if os.path.exists(filename):
             # This file exists and we should continue processing
             inVisitCat = visitCatDataRef.get()
             if len(inVisitCat) != len(groupedDataRefs):
                 raise RuntimeError("Existing visitCatalog found, but has an inconsistent "
                                    "number of visits.  Cannot continue.")
         else:
             inVisitCat = None
  
         visitCat = self.fgcmMakeVisitCatalog(camera, groupedDataRefs,
                                              visitCatDataRef=visitCatDataRef,
                                              inVisitCat=inVisitCat)
  
         # Persist the visitCat as a checkpoint file.
         visitCatDataRef.put(visitCat)
  
         starObsDataRef = butler.dataRef('fgcmStarObservations')
         filename = starObsDataRef.get('fgcmStarObservations_filename')[0]
         if os.path.exists(filename):
             inStarObsCat = starObsDataRef.get()
         else:
             inStarObsCat = None
  
         rad = calibFluxApertureRadius
         sourceSchemaDataRef = butler.dataRef('src_schema')
         sourceSchema = sourceSchemaDataRef.get('src_schema', immediate=True).schema
         fgcmStarObservationCat = self.fgcmMakeAllStarObservations(groupedDataRefs,
                                                                   visitCat,
                                                                   sourceSchema,
                                                                   camera,
                                                                   calibFluxApertureRadius=rad,
                                                                   starObsDataRef=starObsDataRef,
                                                                   visitCatDataRef=visitCatDataRef,
                                                                   inStarObsCat=inStarObsCat)
         visitCatDataRef.put(visitCat)
         starObsDataRef.put(fgcmStarObservationCat)
  
         # Always do the matching.
         if self.config.doReferenceMatches:
             lutDataRef = butler.dataRef('fgcmLookUpTable')
         else:
             lutDataRef = None
         fgcmStarIdCat, fgcmStarIndicesCat, fgcmRefCat = self.fgcmMatchStars(visitCat,
                                                                             fgcmStarObservationCat,
                                                                             lutDataRef=lutDataRef)
  
         # Persist catalogs via the butler
         butler.put(fgcmStarIdCat, 'fgcmStarIds')
         butler.put(fgcmStarIndicesCat, 'fgcmStarIndices')
         if fgcmRefCat is not None:
             butler.put(fgcmRefCat, 'fgcmReferenceStars')
  

◆ runQuantum()

def lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.runQuantum	(	self,
		butlerQC,
		inputRefs,
		outputRefs
	)

Definition at line 230 of file fgcmBuildStarsTable.py.

     def runQuantum(self, butlerQC, inputRefs, outputRefs):
         inputRefDict = butlerQC.get(inputRefs)
  
         sourceTableRefs = inputRefDict['sourceTable_visit']
  
         self.log.info("Running with %d sourceTable_visit dataRefs",
                       len(sourceTableRefs))
  
         sourceTableDataRefDict = {sourceTableRef.dataId['visit']: sourceTableRef for
                                   sourceTableRef in sourceTableRefs}
  
         if self.config.doReferenceMatches:
             # Get the LUT dataRef
             lutDataRef = inputRefDict['fgcmLookUpTable']
  
             # Prepare the refCat loader
             refConfig = self.config.fgcmLoadReferenceCatalog.refObjLoader
             refObjLoader = ReferenceObjectLoader(dataIds=[ref.datasetRef.dataId
                                                           for ref in inputRefs.refCat],
                                                  refCats=butlerQC.get(inputRefs.refCat),
                                                  config=refConfig,
                                                  log=self.log)
             self.makeSubtask('fgcmLoadReferenceCatalog', refObjLoader=refObjLoader)
         else:
             lutDataRef = None
  
         # Compute aperture radius if necessary.  This is useful to do now before
         # any heave lifting has happened (fail early).
         calibFluxApertureRadius = None
         if self.config.doSubtractLocalBackground:
             try:
                 calibFluxApertureRadius = computeApertureRadiusFromDataRef(sourceTableRefs[0],
                                                                            self.config.instFluxField)
             except RuntimeError as e:
                 raise RuntimeError("Could not determine aperture radius from %s. "
                                    "Cannot use doSubtractLocalBackground." %
                                    (self.config.instFluxField)) from e
  
         visitSummaryRefs = inputRefDict['visitSummary']
         visitSummaryDataRefDict = {visitSummaryRef.dataId['visit']: visitSummaryRef for
                                    visitSummaryRef in visitSummaryRefs}
  
         camera = inputRefDict['camera']
         groupedDataRefs = self._groupDataRefs(sourceTableDataRefDict,
                                               visitSummaryDataRefDict)
  
         if self.config.doModelErrorsWithBackground:
             bkgRefs = inputRefDict['background']
             bkgDataRefDict = {(bkgRef.dataId.byName()['visit'],
                                bkgRef.dataId.byName()['detector']): bkgRef for
                               bkgRef in bkgRefs}
         else:
             bkgDataRefDict = None
  
         # Gen3 does not currently allow "checkpoint" saving of datasets,
         # so we need to have this all in one go.
         visitCat = self.fgcmMakeVisitCatalog(camera, groupedDataRefs,
                                              bkgDataRefDict=bkgDataRefDict,
                                              visitCatDataRef=None,
                                              inVisitCat=None)
  
         rad = calibFluxApertureRadius
         # sourceSchemaDataRef = inputRefDict['sourceSchema']
         fgcmStarObservationCat = self.fgcmMakeAllStarObservations(groupedDataRefs,
                                                                   visitCat,
                                                                   self.sourceSchema,
                                                                   camera,
                                                                   calibFluxApertureRadius=rad,
                                                                   starObsDataRef=None,
                                                                   visitCatDataRef=None,
                                                                   inStarObsCat=None)
  
         butlerQC.put(visitCat, outputRefs.fgcmVisitCatalog)
         butlerQC.put(fgcmStarObservationCat, outputRefs.fgcmStarObservations)
  
         fgcmStarIdCat, fgcmStarIndicesCat, fgcmRefCat = self.fgcmMatchStars(visitCat,
                                                                             fgcmStarObservationCat,
                                                                             lutDataRef=lutDataRef)
  
         butlerQC.put(fgcmStarIdCat, outputRefs.fgcmStarIds)
         butlerQC.put(fgcmStarIndicesCat, outputRefs.fgcmStarIndices)
         if fgcmRefCat is not None:
             butlerQC.put(fgcmRefCat, outputRefs.fgcmReferenceStars)
  

Member Data Documentation

◆ canMultiprocess

bool lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.canMultiprocess = False

static

Definition at line 223 of file fgcmBuildStarsTable.py.

◆ ConfigClass

lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.ConfigClass = FgcmBuildStarsTableConfig

static

Definition at line 219 of file fgcmBuildStarsTable.py.

◆ RunnerClass

lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.RunnerClass = FgcmBuildStarsRunner

static

Definition at line 220 of file fgcmBuildStarsTable.py.

◆ sourceSchema

lsst.fgcmcal.fgcmBuildStarsTable.FgcmBuildStarsTableTask.sourceSchema

Definition at line 228 of file fgcmBuildStarsTable.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/fgcmcal/22.0.1-12-g9c3108e+df145f6f68/python/lsst/fgcmcal/fgcmBuildStarsTable.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ fgcmMakeAllStarObservations()

◆ fgcmMakeVisitCatalog()

◆ fgcmMatchStars()

◆ runDataRef()

◆ runQuantum()

Member Data Documentation

◆ canMultiprocess

◆ ConfigClass

◆ RunnerClass

◆ sourceSchema

◆ init()