Inheritance diagram for lsst.fgcmcal.fgcmBuildStars.FgcmBuildStarsTask:

Public Member Functions
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)

Static Public Attributes
	ConfigClass = FgcmBuildStarsConfig

	RunnerClass = FgcmBuildStarsRunner

Detailed Description

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

Definition at line 91 of file fgcmBuildStars.py.

Member Function Documentation

◆ fgcmMakeAllStarObservations()

def lsst.fgcmcal.fgcmBuildStars.FgcmBuildStarsTask.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 180 of file fgcmBuildStars.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.")
  
         # create our source schema.  Use the first valid dataRef
         dataRef = groupedDataRefs[list(groupedDataRefs.keys())[0]][0]
  
         # Construct a mapping from ccd number to index
         ccdMapping = {}
         for ccdIndex, detector in enumerate(camera):
             ccdMapping[detector.getId()] = ccdIndex
  
         approxPixelAreaFields = computeApproxPixelAreaFields(camera)
  
         sourceMapper = self._makeSourceMapper(sourceSchema)
  
         # We also have a temporary catalog that will accumulate aperture measurements
         aperMapper = self._makeAperMapper(sourceSchema)
  
         outputSchema = sourceMapper.getOutputSchema()
  
         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)
  
         # FGCM will provide relative calibration for the flux in config.instFluxField
  
         instFluxKey = sourceSchema[self.config.instFluxField].asKey()
         instFluxErrKey = sourceSchema[self.config.instFluxField + 'Err'].asKey()
         visitKey = outputSchema['visit'].asKey()
         ccdKey = outputSchema['ccd'].asKey()
         instMagKey = outputSchema['instMag'].asKey()
         instMagErrKey = outputSchema['instMagErr'].asKey()
         deltaMagBkgKey = outputSchema['deltaMagBkg'].asKey()
  
         # Prepare local background if desired
         if self.config.doSubtractLocalBackground:
             localBackgroundFluxKey = sourceSchema[self.config.localBackgroundFluxField].asKey()
             localBackgroundArea = np.pi*calibFluxApertureRadius**2.
  
         aperOutputSchema = aperMapper.getOutputSchema()
  
         instFluxAperInKey = sourceSchema[self.config.apertureInnerInstFluxField].asKey()
         instFluxErrAperInKey = sourceSchema[self.config.apertureInnerInstFluxField + 'Err'].asKey()
         instFluxAperOutKey = sourceSchema[self.config.apertureOuterInstFluxField].asKey()
         instFluxErrAperOutKey = sourceSchema[self.config.apertureOuterInstFluxField + 'Err'].asKey()
         instMagInKey = aperOutputSchema['instMag_aper_inner'].asKey()
         instMagErrInKey = aperOutputSchema['instMagErr_aper_inner'].asKey()
         instMagOutKey = aperOutputSchema['instMag_aper_outer'].asKey()
         instMagErrOutKey = aperOutputSchema['instMagErr_aper_outer'].asKey()
  
         k = 2.5/np.log(10.)
  
         # loop over visits
         for ctr, visit in enumerate(visitCat):
             if visit['sources_read']:
                 continue
  
             expTime = visit['exptime']
  
             nStarInVisit = 0
  
             # Reset the aperture catalog (per visit)
             aperVisitCatalog = afwTable.BaseCatalog(aperOutputSchema)
  
             for dataRef in groupedDataRefs[visit['visit']]:
  
                 ccdId = dataRef.dataId[self.config.ccdDataRefName]
  
                 sources = dataRef.get(datasetType='src', flags=afwTable.SOURCE_IO_NO_FOOTPRINTS)
                 goodSrc = self.sourceSelector.selectSources(sources)
  
                 # Need to add a selection based on the local background correction
                 # if necessary
                 if self.config.doSubtractLocalBackground:
                     localBackground = localBackgroundArea*sources[localBackgroundFluxKey]
  
                     bad, = np.where((sources[instFluxKey] - localBackground) <= 0.0)
                     goodSrc.selected[bad] = False
  
                 tempCat = afwTable.BaseCatalog(fullCatalog.schema)
                 tempCat.reserve(goodSrc.selected.sum())
                 tempCat.extend(sources[goodSrc.selected], mapper=sourceMapper)
                 tempCat[visitKey][:] = visit['visit']
                 tempCat[ccdKey][:] = ccdId
  
                 # Compute "instrumental magnitude" by scaling flux with exposure time.
                 scaledInstFlux = (sources[instFluxKey][goodSrc.selected]
                                   * visit['scaling'][ccdMapping[ccdId]])
                 tempCat[instMagKey][:] = (-2.5*np.log10(scaledInstFlux) + 2.5*np.log10(expTime))
  
                 # Compute the change in magnitude from the background offset
                 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 background correction
                     # and the mag without background correction.
                     tempCat[deltaMagBkgKey][:] = (-2.5*np.log10(sources[instFluxKey][goodSrc.selected]
                                                                 - localBackground[goodSrc.selected]) -
                                                   -2.5*np.log10(sources[instFluxKey][goodSrc.selected]))
                 else:
                     tempCat[deltaMagBkgKey][:] = 0.0
  
                 # Compute instMagErr from instFluxErr/instFlux, any scaling
                 # will cancel out.
  
                 tempCat[instMagErrKey][:] = k*(sources[instFluxErrKey][goodSrc.selected]
                                                / sources[instFluxKey][goodSrc.selected])
  
                 # Compute the jacobian from an approximate PixelAreaBoundedField
                 tempCat['jacobian'] = approxPixelAreaFields[ccdId].evaluate(tempCat['x'],
                                                                             tempCat['y'])
  
                 # Apply the jacobian if configured
                 if self.config.doApplyWcsJacobian:
                     tempCat[instMagKey][:] -= 2.5*np.log10(tempCat['jacobian'][:])
  
                 fullCatalog.extend(tempCat)
  
                 # And the aperture information
                 # This does not need the jacobian because it is all locally relative
                 tempAperCat = afwTable.BaseCatalog(aperVisitCatalog.schema)
                 tempAperCat.reserve(goodSrc.selected.sum())
                 tempAperCat.extend(sources[goodSrc.selected], mapper=aperMapper)
  
                 with np.warnings.catch_warnings():
                     # Ignore warnings, we will filter infinities and
                     # nans below.
                     np.warnings.simplefilter("ignore")
  
                     tempAperCat[instMagInKey][:] = -2.5*np.log10(
                         sources[instFluxAperInKey][goodSrc.selected])
                     tempAperCat[instMagErrInKey][:] = k*(
                         sources[instFluxErrAperInKey][goodSrc.selected]
                         / sources[instFluxAperInKey][goodSrc.selected])
                     tempAperCat[instMagOutKey][:] = -2.5*np.log10(
                         sources[instFluxAperOutKey][goodSrc.selected])
                     tempAperCat[instMagErrOutKey][:] = k*(
                         sources[instFluxErrAperOutKey][goodSrc.selected]
                         / sources[instFluxAperOutKey][goodSrc.selected])
  
                 aperVisitCatalog.extend(tempAperCat)
  
                 nStarInVisit += len(tempCat)
  
             # Compute the median delta-aper
             if not aperVisitCatalog.isContiguous():
                 aperVisitCatalog = aperVisitCatalog.copy(deep=True)
  
             instMagIn = aperVisitCatalog[instMagInKey]
             instMagErrIn = aperVisitCatalog[instMagErrInKey]
             instMagOut = aperVisitCatalog[instMagOutKey]
             instMagErrOut = aperVisitCatalog[instMagErrOutKey]
  
             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 = %.3f)" %
                           (nStarInVisit, visit['visit'], visit['deltaAper']))
  
             if ((ctr % 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 460 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 687 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 296 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')
  

Member Data Documentation

◆ ConfigClass

lsst.fgcmcal.fgcmBuildStars.FgcmBuildStarsTask.ConfigClass = FgcmBuildStarsConfig

static

Definition at line 95 of file fgcmBuildStars.py.

◆ RunnerClass

lsst.fgcmcal.fgcmBuildStars.FgcmBuildStarsTask.RunnerClass = FgcmBuildStarsRunner

static

Definition at line 96 of file fgcmBuildStars.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-15-g6a90155+515f58c32b/python/lsst/fgcmcal/fgcmBuildStars.py

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ fgcmMakeAllStarObservations()

◆ fgcmMakeVisitCatalog()

◆ fgcmMatchStars()

◆ runDataRef()

Member Data Documentation

◆ ConfigClass

◆ RunnerClass