lsst.fgcmcal.utilities Namespace Reference

Functions
	makeConfigDict (config, log, camera, maxIter, resetFitParameters, outputZeropoints, lutFilterNames, tract=None, nCore=1, doPlots=False)
	translateFgcmLut (lutCat, physicalFilterMap)
	translateVisitCatalog (visitCat)
	_computeDefaultVisitInfo ()
	computeReferencePixelScale (camera)
	computePixelAreaFieldDetector (detector, visitInfo=None, areaScaling=1.0, approximate=False)
	computeApproxPixelAreaFields (camera)
	makeZptSchema (superStarChebyshevSize, zptChebyshevSize)
	makeZptCat (zptSchema, zpStruct)
	makeAtmSchema ()
	makeAtmCat (atmSchema, atmStruct)
	makeStdSchema (nBands)
	makeStdCat (stdSchema, stdStruct, goodBands)
	computeApertureRadiusFromName (fluxField)
	extractReferenceMags (refStars, bands, filterMap)
	lookupStaticCalibrations (datasetType, registry, quantumDataId, collections)

Variables
str	FGCM_EXP_FIELD = 'VISIT'
str	FGCM_CCD_FIELD = 'DETECTOR'
float	FGCM_ILLEGAL_VALUE = -9999.0

Detailed Description

Utility functions for fgcmcal.

This file contains utility functions that are used by more than one task,
and do not need to be part of a task.

Function Documentation

_computeDefaultVisitInfo()

lsst.fgcmcal.utilities._computeDefaultVisitInfo ( )

protected

Compute a default visitInfo for use with pixel scale / jacobians.

Returns
-------
visitInfo : `lsst.afw.image.VisitInfo`
    The visit info object.

Definition at line 438 of file utilities.py.

def _computeDefaultVisitInfo():
    """
    Compute a default visitInfo for use with pixel scale / jacobians.
 
    Returns
    -------
    visitInfo : `lsst.afw.image.VisitInfo`
        The visit info object.
    """
    # Generate fake WCSs centered at 180/0 to avoid the RA=0/360 problem,
    # since we are looking for relative scales
    boresight = geom.SpherePoint(180.0*geom.degrees, 0.0*geom.degrees)
    orientation = 0.0*geom.degrees
 
    # Create a temporary visitInfo for input to createInitialSkyWcs
    # The orientation does not matter for the area computation
    visitInfo = afwImage.VisitInfo(boresightRaDec=boresight,
                                   boresightRotAngle=orientation,
                                   rotType=afwImage.RotType.SKY)
    return visitInfo
 
 

computeApertureRadiusFromName()

lsst.fgcmcal.utilities.computeApertureRadiusFromName

(

fluxField

)

Compute the radius associated with a CircularApertureFlux or ApFlux field.

Parameters
----------
fluxField : `str`
   CircularApertureFlux or ApFlux

Returns
-------
apertureRadius : `float`
    Radius of the aperture field, in pixels.

Raises
------
 RuntimeError: Raised if flux field is not a CircularApertureFlux,
   ApFlux, or apFlux.

Definition at line 830 of file utilities.py.

def computeApertureRadiusFromName(fluxField):
    """
    Compute the radius associated with a CircularApertureFlux or ApFlux field.
 
    Parameters
    ----------
    fluxField : `str`
       CircularApertureFlux or ApFlux
 
    Returns
    -------
    apertureRadius : `float`
        Radius of the aperture field, in pixels.
 
    Raises
    ------
     RuntimeError: Raised if flux field is not a CircularApertureFlux,
       ApFlux, or apFlux.
    """
    # TODO: Move this method to more general stack method in DM-25775
    m = re.search(r'(CircularApertureFlux|ApFlux|apFlux)_(\d+)_(\d+)_', fluxField)
 
    if m is None:
        raise RuntimeError(f"Flux field {fluxField} does not correspond to a CircularApertureFlux or ApFlux")
 
    apertureRadius = float(m.groups()[1]) + float(m.groups()[2])/10.
 
    return apertureRadius
 
 

computeApproxPixelAreaFields()

lsst.fgcmcal.utilities.computeApproxPixelAreaFields

(

camera

)

Compute the approximate pixel area bounded fields from the camera
geometry.

Parameters
----------
camera: `lsst.afw.cameraGeom.Camera`

Returns
-------
approxPixelAreaFields: `dict`
   Dictionary of approximate area fields, keyed with detector ID

Definition at line 521 of file utilities.py.

def computeApproxPixelAreaFields(camera):
    """
    Compute the approximate pixel area bounded fields from the camera
    geometry.
 
    Parameters
    ----------
    camera: `lsst.afw.cameraGeom.Camera`
 
    Returns
    -------
    approxPixelAreaFields: `dict`
       Dictionary of approximate area fields, keyed with detector ID
    """
 
    areaScaling = 1. / computeReferencePixelScale(camera)**2.
 
    visitInfo = _computeDefaultVisitInfo()
 
    approxPixelAreaFields = {}
 
    for i, detector in enumerate(camera):
        key = detector.getId()
 
        approxAreaField = computePixelAreaFieldDetector(
            detector,
            visitInfo=visitInfo,
            areaScaling=areaScaling,
            approximate=True,
        )
 
        approxPixelAreaFields[key] = approxAreaField
 
    return approxPixelAreaFields
 
 

computePixelAreaFieldDetector()

lsst.fgcmcal.utilities.computePixelAreaFieldDetector	(		detector,
			visitInfo = None,
			areaScaling = 1.0,
			approximate = False )

Compute the reference pixel area field for a detector.

Parameters
----------
visitInfo : `lsst.afw.image.VisitInfo`
    The visit info object.
detector : `lsst.afw.cameraGeom.detector`
    The detector object.
visitInfo : `lsst.afw.image.VisitInfo`, optional
    If not supplied, will compute a default visitInfo.
areaScaling : `float`, optional
    Area scaling factor.
approximate : `bool`, optional
    Compute Chebyshev approximation to pixel area field?

Returns
-------
pixelAreaField : `lsst.afw.math.BoundedField`
    Bounded field describing the pixel area from the detector model.

Definition at line 480 of file utilities.py.

def computePixelAreaFieldDetector(detector, visitInfo=None, areaScaling=1.0, approximate=False):
    """
    Compute the reference pixel area field for a detector.
 
    Parameters
    ----------
    visitInfo : `lsst.afw.image.VisitInfo`
        The visit info object.
    detector : `lsst.afw.cameraGeom.detector`
        The detector object.
    visitInfo : `lsst.afw.image.VisitInfo`, optional
        If not supplied, will compute a default visitInfo.
    areaScaling : `float`, optional
        Area scaling factor.
    approximate : `bool`, optional
        Compute Chebyshev approximation to pixel area field?
 
    Returns
    -------
    pixelAreaField : `lsst.afw.math.BoundedField`
        Bounded field describing the pixel area from the detector model.
    """
    if visitInfo is None:
        visitInfo = _computeDefaultVisitInfo()
 
    wcs = createInitialSkyWcs(visitInfo, detector, False)
    bbox = detector.getBBox()
 
    pixelAreaField = afwMath.PixelAreaBoundedField(
        bbox,
        wcs,
        unit=geom.arcseconds,
        scaling=areaScaling,
    )
 
    if approximate:
        pixelAreaField = afwMath.ChebyshevBoundedField.approximate(pixelAreaField)
 
    return pixelAreaField
 
 

computeReferencePixelScale()

lsst.fgcmcal.utilities.computeReferencePixelScale

(

camera

)

Compute the median pixel scale in the camera

Returns
-------
pixelScale: `float`
   Average pixel scale (arcsecond) over the camera

Definition at line 460 of file utilities.py.

def computeReferencePixelScale(camera):
    """
    Compute the median pixel scale in the camera
 
    Returns
    -------
    pixelScale: `float`
       Average pixel scale (arcsecond) over the camera
    """
    visitInfo = _computeDefaultVisitInfo()
 
    pixelScales = np.zeros(len(camera))
    for i, detector in enumerate(camera):
        wcs = createInitialSkyWcs(visitInfo, detector, False)
        pixelScales[i] = wcs.getPixelScale(detector.getBBox().getCenter()).asArcseconds()
 
    ok, = np.where(pixelScales > 0.0)
    return np.median(pixelScales[ok])
 
 

extractReferenceMags()

lsst.fgcmcal.utilities.extractReferenceMags	(		refStars,
			bands,
			filterMap )

Extract reference magnitudes from refStars for given bands and
associated filterMap.

Parameters
----------
refStars : `astropy.table.Table` or `lsst.afw.table.BaseCatalog`
    FGCM reference star catalog.
bands : `list`
    List of bands for calibration.
filterMap: `dict`
    FGCM mapping of filter to band.

Returns
-------
refMag : `np.ndarray`
    nstar x nband array of reference magnitudes.
refMagErr : `np.ndarray`
    nstar x nband array of reference magnitude errors.

Definition at line 860 of file utilities.py.

def extractReferenceMags(refStars, bands, filterMap):
    """
    Extract reference magnitudes from refStars for given bands and
    associated filterMap.
 
    Parameters
    ----------
    refStars : `astropy.table.Table` or `lsst.afw.table.BaseCatalog`
        FGCM reference star catalog.
    bands : `list`
        List of bands for calibration.
    filterMap: `dict`
        FGCM mapping of filter to band.
 
    Returns
    -------
    refMag : `np.ndarray`
        nstar x nband array of reference magnitudes.
    refMagErr : `np.ndarray`
        nstar x nband array of reference magnitude errors.
    """
    hasAstropyMeta = False
    try:
        meta = refStars.meta
        hasAstropyMeta = True
    except AttributeError:
        meta = refStars.getMetadata()
 
    if 'FILTERNAMES' in meta:
        if hasAstropyMeta:
            filternames = meta['FILTERNAMES']
        else:
            filternames = meta.getArray('FILTERNAMES')
 
        # The reference catalog that fgcm wants has one entry per band
        # in the config file
        refMag = np.zeros((len(refStars), len(bands)),
                          dtype=refStars['refMag'].dtype) + 99.0
        refMagErr = np.zeros_like(refMag) + 99.0
        for i, filtername in enumerate(filternames):
            # We are allowed to run the fit configured so that we do not
            # use every column in the reference catalog.
            try:
                band = filterMap[filtername]
            except KeyError:
                continue
            try:
                ind = bands.index(band)
            except ValueError:
                continue
 
            refMag[:, ind] = refStars['refMag'][:, i]
            refMagErr[:, ind] = refStars['refMagErr'][:, i]
    else:
        raise RuntimeError("FGCM reference stars missing FILTERNAMES metadata.")
 
    return refMag, refMagErr
 
 

lookupStaticCalibrations()

lsst.fgcmcal.utilities.lookupStaticCalibrations	(		datasetType,
			registry,
			quantumDataId,
			collections )

Definition at line 919 of file utilities.py.

def lookupStaticCalibrations(datasetType, registry, quantumDataId, collections):
    # For static calibrations, we search with a timespan that has unbounded
    # begin and end; we'll get an error if there's more than one match (because
    # then it's not static).
    timespan = Timespan(begin=None, end=None)
    result = []
    # First iterate over all of the data IDs for this dataset type that are
    # consistent with the quantum data ID.
    for dataId in registry.queryDataIds(datasetType.dimensions, dataId=quantumDataId):
        # Find the dataset with this data ID using the unbounded timespan.
        if ref := registry.findDataset(datasetType, dataId, collections=collections, timespan=timespan):
            result.append(ref)
    return result

makeAtmCat()

lsst.fgcmcal.utilities.makeAtmCat	(		atmSchema,
			atmStruct )

Make the atmosphere catalog for persistence

Parameters
----------
atmSchema: `lsst.afw.table.Schema`
   Atmosphere catalog schema
atmStruct: `numpy.ndarray`
   Atmosphere structure from fgcm

Returns
-------
atmCat: `lsst.afw.table.BaseCatalog`
   Atmosphere catalog for persistence

Definition at line 722 of file utilities.py.

def makeAtmCat(atmSchema, atmStruct):
    """
    Make the atmosphere catalog for persistence
 
    Parameters
    ----------
    atmSchema: `lsst.afw.table.Schema`
       Atmosphere catalog schema
    atmStruct: `numpy.ndarray`
       Atmosphere structure from fgcm
 
    Returns
    -------
    atmCat: `lsst.afw.table.BaseCatalog`
       Atmosphere catalog for persistence
    """
 
    atmCat = afwTable.BaseCatalog(atmSchema)
    atmCat.resize(atmStruct.size)
 
    atmCat['visit'][:] = atmStruct['VISIT']
    atmCat['pmb'][:] = atmStruct['PMB']
    atmCat['pwv'][:] = atmStruct['PWV']
    atmCat['tau'][:] = atmStruct['TAU']
    atmCat['alpha'][:] = atmStruct['ALPHA']
    atmCat['o3'][:] = atmStruct['O3']
    atmCat['secZenith'][:] = atmStruct['SECZENITH']
    atmCat['cTrans'][:] = atmStruct['CTRANS']
    atmCat['lamStd'][:] = atmStruct['LAMSTD']
 
    return atmCat
 
 

makeAtmSchema()

lsst.fgcmcal.utilities.makeAtmSchema

(

)

Make the atmosphere schema

Returns
-------
atmSchema: `lsst.afw.table.Schema`

Definition at line 698 of file utilities.py.

def makeAtmSchema():
    """
    Make the atmosphere schema
 
    Returns
    -------
    atmSchema: `lsst.afw.table.Schema`
    """
 
    atmSchema = afwTable.Schema()
 
    atmSchema.addField('visit', type=np.int64, doc='Visit number')
    atmSchema.addField('pmb', type=np.float64, doc='Barometric pressure (mb)')
    atmSchema.addField('pwv', type=np.float64, doc='Water vapor (mm)')
    atmSchema.addField('tau', type=np.float64, doc='Aerosol optical depth')
    atmSchema.addField('alpha', type=np.float64, doc='Aerosol slope')
    atmSchema.addField('o3', type=np.float64, doc='Ozone (dobson)')
    atmSchema.addField('secZenith', type=np.float64, doc='Secant(zenith) (~ airmass)')
    atmSchema.addField('cTrans', type=np.float64, doc='Transmission correction factor')
    atmSchema.addField('lamStd', type=np.float64, doc='Wavelength for transmission correction')
 
    return atmSchema
 
 

makeConfigDict()

lsst.fgcmcal.utilities.makeConfigDict	(		config,
			log,
			camera,
			maxIter,
			resetFitParameters,
			outputZeropoints,
			lutFilterNames,
			tract = None,
			nCore = 1,
			doPlots = False )

Make the FGCM fit cycle configuration dict

Parameters
----------
config : `lsst.fgcmcal.FgcmFitCycleConfig`
    Configuration object
log : `logging.Logger`
    Log object.
camera : `lsst.afw.cameraGeom.Camera`
    Camera from the butler
maxIter : `int`
    Maximum number of iterations
resetFitParameters: `bool`
    Reset fit parameters before fitting?
outputZeropoints : `bool`
    Compute zeropoints for output?
lutFilterNames : array-like, `str`
    Array of physical filter names in the LUT.
tract : `int`, optional
    Tract number for extending the output file name for debugging.
    Default is None.
nCore : `int`, optional
    Number of cores to use.
doPlots : `bool`, optional
    Make FGCM QA plots?

Returns
-------
configDict : `dict`
    Configuration dictionary for fgcm

Definition at line 47 of file utilities.py.

                   lutFilterNames, tract=None, nCore=1, doPlots=False):
    """
    Make the FGCM fit cycle configuration dict
 
    Parameters
    ----------
    config : `lsst.fgcmcal.FgcmFitCycleConfig`
        Configuration object
    log : `logging.Logger`
        Log object.
    camera : `lsst.afw.cameraGeom.Camera`
        Camera from the butler
    maxIter : `int`
        Maximum number of iterations
    resetFitParameters: `bool`
        Reset fit parameters before fitting?
    outputZeropoints : `bool`
        Compute zeropoints for output?
    lutFilterNames : array-like, `str`
        Array of physical filter names in the LUT.
    tract : `int`, optional
        Tract number for extending the output file name for debugging.
        Default is None.
    nCore : `int`, optional
        Number of cores to use.
    doPlots : `bool`, optional
        Make FGCM QA plots?
 
    Returns
    -------
    configDict : `dict`
        Configuration dictionary for fgcm
    """
    # Extract the bands that are _not_ being fit for fgcm configuration
    notFitBands = [b for b in config.bands if b not in config.fitBands]
 
    # process the starColorCuts
    starColorCutList = []
    for ccut in config.starColorCuts:
        if ccut == 'NO_DATA':
            # No color cuts to apply.
            break
        parts = ccut.split(',')
        starColorCutList.append([parts[0], parts[1], float(parts[2]), float(parts[3])])
 
    # process the refStarColorCuts
    refStarColorCutList = []
    for ccut in config.refStarColorCuts:
        if ccut == 'NO_DATA':
            # No color cuts to apply.
            break
        parts = ccut.split(',')
        refStarColorCutList.append([parts[0], parts[1], float(parts[2]), float(parts[3])])
 
    # TODO: Having direct access to the mirror area from the camera would be
    #  useful.  See DM-16489.
    # Mirror area in cm**2
    if config.mirrorArea is None:
        mirrorArea = np.pi*(camera.telescopeDiameter*100./2.)**2.
    else:
        # Convert to square cm.
        mirrorArea = config.mirrorArea * 100.**2.
 
    if config.cameraGain is None:
        # Get approximate average camera gain:
        gains = [amp.getGain() for detector in camera for amp in detector.getAmplifiers()]
        cameraGain = float(np.median(gains))
    else:
        cameraGain = config.cameraGain
 
    # Cut down the filter map to those that are in the LUT
    filterToBand = {filterName: config.physicalFilterMap[filterName] for
                    filterName in lutFilterNames}
 
    if tract is None:
        outfileBase = config.outfileBase
    else:
        outfileBase = '%s-%06d' % (config.outfileBase, tract)
 
    # create a configuration dictionary for fgcmFitCycle
    configDict = {'outfileBase': outfileBase,
                  'logger': log,
                  'exposureFile': None,
                  'obsFile': None,
                  'indexFile': None,
                  'lutFile': None,
                  'mirrorArea': mirrorArea,
                  'cameraGain': cameraGain,
                  'ccdStartIndex': camera[0].getId(),
                  'expField': FGCM_EXP_FIELD,
                  'ccdField': FGCM_CCD_FIELD,
                  'seeingField': 'DELTA_APER',
                  'fwhmField': 'PSFFWHM',
                  'skyBrightnessField': 'SKYBACKGROUND',
                  'deepFlag': 'DEEPFLAG',  # unused
                  'bands': list(config.bands),
                  'fitBands': list(config.fitBands),
                  'notFitBands': notFitBands,
                  'requiredBands': list(config.requiredBands),
                  'filterToBand': filterToBand,
                  'logLevel': 'INFO',
                  'nCore': nCore,
                  'nStarPerRun': config.nStarPerRun,
                  'nExpPerRun': config.nExpPerRun,
                  'reserveFraction': config.reserveFraction,
                  'freezeStdAtmosphere': config.freezeStdAtmosphere,
                  'precomputeSuperStarInitialCycle': config.precomputeSuperStarInitialCycle,
                  'superStarSubCCDDict': dict(config.superStarSubCcdDict),
                  'superStarSubCCDChebyshevOrder': config.superStarSubCcdChebyshevOrder,
                  'superStarSubCCDTriangular': config.superStarSubCcdTriangular,
                  'superStarSigmaClip': config.superStarSigmaClip,
                  'superStarPlotCCDResiduals': config.superStarPlotCcdResiduals,
                  'superStarForceZeroMean': config.superStarForceZeroMean,
                  'focalPlaneSigmaClip': config.focalPlaneSigmaClip,
                  'ccdGraySubCCDDict': dict(config.ccdGraySubCcdDict),
                  'ccdGraySubCCDChebyshevOrder': config.ccdGraySubCcdChebyshevOrder,
                  'ccdGraySubCCDTriangular': config.ccdGraySubCcdTriangular,
                  'ccdGrayFocalPlaneDict': dict(config.ccdGrayFocalPlaneDict),
                  'ccdGrayFocalPlaneChebyshevOrder': config.ccdGrayFocalPlaneChebyshevOrder,
                  'ccdGrayFocalPlaneFitMinCcd': config.ccdGrayFocalPlaneFitMinCcd,
                  'cycleNumber': config.cycleNumber,
                  'maxIter': maxIter,
                  'deltaMagBkgOffsetPercentile': config.deltaMagBkgOffsetPercentile,
                  'deltaMagBkgPerCcd': config.deltaMagBkgPerCcd,
                  'UTBoundary': config.utBoundary,
                  'washMJDs': config.washMjds,
                  'epochMJDs': config.epochMjds,
                  'coatingMJDs': config.coatingMjds,
                  'minObsPerBand': config.minObsPerBand,
                  'latitude': config.latitude,
                  'defaultCameraOrientation': config.defaultCameraOrientation,
                  'brightObsGrayMax': config.brightObsGrayMax,
                  'minStarPerCCD': config.minStarPerCcd,
                  'minCCDPerExp': config.minCcdPerExp,
                  'maxCCDGrayErr': config.maxCcdGrayErr,
                  'minStarPerExp': config.minStarPerExp,
                  'minExpPerNight': config.minExpPerNight,
                  'expGrayInitialCut': config.expGrayInitialCut,
                  'expFwhmCutDict': dict(config.expFwhmCutDict),
                  'expGrayPhotometricCutDict': dict(config.expGrayPhotometricCutDict),
                  'expGrayHighCutDict': dict(config.expGrayHighCutDict),
                  'expGrayRecoverCut': config.expGrayRecoverCut,
                  'expVarGrayPhotometricCutDict': dict(config.expVarGrayPhotometricCutDict),
                  'expGrayErrRecoverCut': config.expGrayErrRecoverCut,
                  'refStarSnMin': config.refStarSnMin,
                  'refStarOutlierNSig': config.refStarOutlierNSig,
                  'applyRefStarColorCuts': config.applyRefStarColorCuts,
                  'refStarMaxFracUse': config.refStarMaxFracUse,
                  'useExposureReferenceOffset': config.useExposureReferenceOffset,
                  'illegalValue': FGCM_ILLEGAL_VALUE,  # internally used by fgcm.
                  'starColorCuts': starColorCutList,
                  'refStarColorCuts': refStarColorCutList,
                  'aperCorrFitNBins': config.aperCorrFitNBins,
                  'aperCorrInputSlopeDict': dict(config.aperCorrInputSlopeDict),
                  'sedBoundaryTermDict': config.sedboundaryterms.toDict()['data'],
                  'sedTermDict': config.sedterms.toDict()['data'],
                  'colorSplitBands': list(config.colorSplitBands),
                  'sigFgcmMaxErr': config.sigFgcmMaxErr,
                  'sigFgcmMaxEGrayDict': dict(config.sigFgcmMaxEGrayDict),
                  'ccdGrayMaxStarErr': config.ccdGrayMaxStarErr,
                  'approxThroughputDict': dict(config.approxThroughputDict),
                  'sigmaCalRange': list(config.sigmaCalRange),
                  'sigmaCalFitPercentile': list(config.sigmaCalFitPercentile),
                  'sigmaCalPlotPercentile': list(config.sigmaCalPlotPercentile),
                  'sigma0Phot': config.sigma0Phot,
                  'mapLongitudeRef': config.mapLongitudeRef,
                  'mapNSide': config.mapNSide,
                  'varNSig': 100.0,  # Turn off 'variable star selection' which doesn't work yet
                  'varMinBand': 2,
                  'useRetrievedPwv': False,
                  'useNightlyRetrievedPwv': False,
                  'pwvRetrievalSmoothBlock': 25,
                  'useQuadraticPwv': config.useQuadraticPwv,
                  'useRetrievedTauInit': False,
                  'tauRetrievalMinCCDPerNight': 500,
                  'modelMagErrors': config.modelMagErrors,
                  'instrumentParsPerBand': config.instrumentParsPerBand,
                  'instrumentSlopeMinDeltaT': config.instrumentSlopeMinDeltaT,
                  'fitMirrorChromaticity': config.fitMirrorChromaticity,
                  'fitCCDChromaticityDict': dict(config.fitCcdChromaticityDict),
                  'useRepeatabilityForExpGrayCutsDict': dict(config.useRepeatabilityForExpGrayCutsDict),
                  'autoPhotometricCutNSig': config.autoPhotometricCutNSig,
                  'autoHighCutNSig': config.autoHighCutNSig,
                  'deltaAperInnerRadiusArcsec': config.deltaAperInnerRadiusArcsec,
                  'deltaAperOuterRadiusArcsec': config.deltaAperOuterRadiusArcsec,
                  'deltaAperFitMinNgoodObs': config.deltaAperFitMinNgoodObs,
                  'deltaAperFitPerCcdNx': config.deltaAperFitPerCcdNx,
                  'deltaAperFitPerCcdNy': config.deltaAperFitPerCcdNy,
                  'deltaAperFitSpatialNside': config.deltaAperFitSpatialNside,
                  'doComputeDeltaAperExposures': config.doComputeDeltaAperPerVisit,
                  'doComputeDeltaAperStars': config.doComputeDeltaAperPerStar,
                  'doComputeDeltaAperMap': config.doComputeDeltaAperMap,
                  'doComputeDeltaAperPerCcd': config.doComputeDeltaAperPerCcd,
                  'printOnly': False,
                  'quietMode': config.quietMode,
                  'randomSeed': config.randomSeed,
                  'outputStars': False,
                  'outputPath': os.path.abspath('.'),
                  'clobber': True,
                  'useSedLUT': False,
                  'resetParameters': resetFitParameters,
                  'doPlots': doPlots,
                  'outputFgcmcalZpts': True,  # when outputting zpts, use fgcmcal format
                  'outputZeropoints': outputZeropoints}
 
    return configDict
 
 

makeStdCat()

lsst.fgcmcal.utilities.makeStdCat	(		stdSchema,
			stdStruct,
			goodBands )

Make the standard star catalog for persistence

Parameters
----------
stdSchema: `lsst.afw.table.Schema`
   Standard star catalog schema
stdStruct: `numpy.ndarray`
   Standard star structure in FGCM format
goodBands: `list`
   List of good band names used in stdStruct

Returns
-------
stdCat: `lsst.afw.table.BaseCatalog`
   Standard star catalog for persistence

Definition at line 790 of file utilities.py.

def makeStdCat(stdSchema, stdStruct, goodBands):
    """
    Make the standard star catalog for persistence
 
    Parameters
    ----------
    stdSchema: `lsst.afw.table.Schema`
       Standard star catalog schema
    stdStruct: `numpy.ndarray`
       Standard star structure in FGCM format
    goodBands: `list`
       List of good band names used in stdStruct
 
    Returns
    -------
    stdCat: `lsst.afw.table.BaseCatalog`
       Standard star catalog for persistence
    """
 
    stdCat = afwTable.SimpleCatalog(stdSchema)
    stdCat.resize(stdStruct.size)
 
    stdCat['id'][:] = stdStruct['FGCM_ID']
    stdCat['coord_ra'][:] = stdStruct['RA'] * geom.degrees
    stdCat['coord_dec'][:] = stdStruct['DEC'] * geom.degrees
    stdCat['ngood'][:, :] = stdStruct['NGOOD'][:, :]
    stdCat['ntotal'][:, :] = stdStruct['NTOTAL'][:, :]
    stdCat['mag_std_noabs'][:, :] = stdStruct['MAG_STD'][:, :]
    stdCat['magErr_std'][:, :] = stdStruct['MAGERR_STD'][:, :]
    if 'NPSFCAND' in stdStruct.dtype.names:
        stdCat['npsfcand'][:, :] = stdStruct['NPSFCAND'][:, :]
    stdCat['delta_aper'][:, :] = stdStruct['DELTA_APER'][:, :]
 
    md = PropertyList()
    md.set("BANDS", list(goodBands))
    stdCat.setMetadata(md)
 
    return stdCat
 
 

makeStdSchema()

lsst.fgcmcal.utilities.makeStdSchema

(

nBands

)

Make the standard star schema

Parameters
----------
nBands: `int`
   Number of bands in standard star catalog

Returns
-------
stdSchema: `lsst.afw.table.Schema`

Definition at line 755 of file utilities.py.

def makeStdSchema(nBands):
    """
    Make the standard star schema
 
    Parameters
    ----------
    nBands: `int`
       Number of bands in standard star catalog
 
    Returns
    -------
    stdSchema: `lsst.afw.table.Schema`
    """
 
    stdSchema = afwTable.SimpleTable.makeMinimalSchema()
    stdSchema.addField('ngood', type='ArrayI', doc='Number of good observations',
                       size=nBands)
    stdSchema.addField('ntotal', type='ArrayI', doc='Number of total observations',
                       size=nBands)
    stdSchema.addField('mag_std_noabs', type='ArrayF',
                       doc='Standard magnitude (no absolute calibration)',
                       size=nBands)
    stdSchema.addField('magErr_std', type='ArrayF',
                       doc='Standard magnitude error',
                       size=nBands)
    stdSchema.addField('npsfcand', type='ArrayI',
                       doc='Number of observations flagged as psf candidates',
                       size=nBands)
    stdSchema.addField('delta_aper', type='ArrayF',
                       doc='Delta mag (small - large aperture)',
                       size=nBands)
 
    return stdSchema
 
 

makeZptCat()

lsst.fgcmcal.utilities.makeZptCat	(		zptSchema,
			zpStruct )

Make the zeropoint catalog for persistence

Parameters
----------
zptSchema: `lsst.afw.table.Schema`
   Zeropoint catalog schema
zpStruct: `numpy.ndarray`
   Zeropoint structure from fgcm

Returns
-------
zptCat: `afwTable.BaseCatalog`
   Zeropoint catalog for persistence

Definition at line 643 of file utilities.py.

def makeZptCat(zptSchema, zpStruct):
    """
    Make the zeropoint catalog for persistence
 
    Parameters
    ----------
    zptSchema: `lsst.afw.table.Schema`
       Zeropoint catalog schema
    zpStruct: `numpy.ndarray`
       Zeropoint structure from fgcm
 
    Returns
    -------
    zptCat: `afwTable.BaseCatalog`
       Zeropoint catalog for persistence
    """
 
    zptCat = afwTable.BaseCatalog(zptSchema)
    zptCat.reserve(zpStruct.size)
 
    for filterName in zpStruct['FILTERNAME']:
        rec = zptCat.addNew()
        rec['filtername'] = filterName.decode('utf-8')
 
    zptCat['visit'][:] = zpStruct[FGCM_EXP_FIELD]
    zptCat['detector'][:] = zpStruct[FGCM_CCD_FIELD]
    zptCat['fgcmFlag'][:] = zpStruct['FGCM_FLAG']
    zptCat['fgcmZpt'][:] = zpStruct['FGCM_ZPT']
    zptCat['fgcmZptErr'][:] = zpStruct['FGCM_ZPTERR']
    zptCat['fgcmfZptChebXyMax'][:, :] = zpStruct['FGCM_FZPT_XYMAX']
    zptCat['fgcmfZptCheb'][:, :] = zpStruct['FGCM_FZPT_CHEB']
    zptCat['fgcmfZptSstarCheb'][:, :] = zpStruct['FGCM_FZPT_SSTAR_CHEB']
    zptCat['fgcmI0'][:] = zpStruct['FGCM_I0']
    zptCat['fgcmI10'][:] = zpStruct['FGCM_I10']
    zptCat['fgcmR0'][:] = zpStruct['FGCM_R0']
    zptCat['fgcmR10'][:] = zpStruct['FGCM_R10']
    zptCat['fgcmGry'][:] = zpStruct['FGCM_GRY']
    zptCat['fgcmDeltaChrom'][:] = zpStruct['FGCM_DELTACHROM']
    zptCat['fgcmZptVar'][:] = zpStruct['FGCM_ZPTVAR']
    zptCat['fgcmTilings'][:] = zpStruct['FGCM_TILINGS']
    zptCat['fgcmFpGry'][:] = zpStruct['FGCM_FPGRY']
    zptCat['fgcmFpGryBlue'][:] = zpStruct['FGCM_FPGRY_CSPLIT'][:, 0]
    zptCat['fgcmFpGryBlueErr'][:] = zpStruct['FGCM_FPGRY_CSPLITERR'][:, 0]
    zptCat['fgcmFpGryRed'][:] = zpStruct['FGCM_FPGRY_CSPLIT'][:, 2]
    zptCat['fgcmFpGryRedErr'][:] = zpStruct['FGCM_FPGRY_CSPLITERR'][:, 2]
    zptCat['fgcmFpVar'][:] = zpStruct['FGCM_FPVAR']
    zptCat['fgcmDust'][:] = zpStruct['FGCM_DUST']
    zptCat['fgcmFlat'][:] = zpStruct['FGCM_FLAT']
    zptCat['fgcmAperCorr'][:] = zpStruct['FGCM_APERCORR']
    zptCat['fgcmDeltaMagBkg'][:] = zpStruct['FGCM_DELTAMAGBKG']
    zptCat['exptime'][:] = zpStruct['EXPTIME']
 
    return zptCat
 
 

makeZptSchema()

lsst.fgcmcal.utilities.makeZptSchema	(		superStarChebyshevSize,
			zptChebyshevSize )

Make the zeropoint schema

Parameters
----------
superStarChebyshevSize: `int`
   Length of the superstar chebyshev array
zptChebyshevSize: `int`
   Length of the zeropoint chebyshev array

Returns
-------
zptSchema: `lsst.afw.table.schema`

Definition at line 557 of file utilities.py.

def makeZptSchema(superStarChebyshevSize, zptChebyshevSize):
    """
    Make the zeropoint schema
 
    Parameters
    ----------
    superStarChebyshevSize: `int`
       Length of the superstar chebyshev array
    zptChebyshevSize: `int`
       Length of the zeropoint chebyshev array
 
    Returns
    -------
    zptSchema: `lsst.afw.table.schema`
    """
 
    zptSchema = afwTable.Schema()
 
    zptSchema.addField('visit', type=np.int64, doc='Visit number')
    zptSchema.addField('detector', type=np.int32, doc='Detector ID number')
    zptSchema.addField('fgcmFlag', type=np.int32, doc=('FGCM flag value: '
                                                       '1: Photometric, used in fit; '
                                                       '2: Photometric, not used in fit; '
                                                       '4: Non-photometric, on partly photometric night; '
                                                       '8: Non-photometric, on non-photometric night; '
                                                       '16: No zeropoint could be determined; '
                                                       '32: Too few stars for reliable gray computation'))
    zptSchema.addField('fgcmZpt', type=np.float64, doc='FGCM zeropoint (center of CCD)')
    zptSchema.addField('fgcmZptErr', type=np.float64,
                       doc='Error on zeropoint, estimated from repeatability + number of obs')
    zptSchema.addField('fgcmfZptChebXyMax', type='ArrayD', size=2,
                       doc='maximum x/maximum y to scale to apply chebyshev parameters')
    zptSchema.addField('fgcmfZptCheb', type='ArrayD',
                       size=zptChebyshevSize,
                       doc='Chebyshev parameters (flattened) for zeropoint')
    zptSchema.addField('fgcmfZptSstarCheb', type='ArrayD',
                       size=superStarChebyshevSize,
                       doc='Chebyshev parameters (flattened) for superStarFlat')
    zptSchema.addField('fgcmI0', type=np.float64, doc='Integral of the passband')
    zptSchema.addField('fgcmI10', type=np.float64, doc='Normalized chromatic integral')
    zptSchema.addField('fgcmR0', type=np.float64,
                       doc='Retrieved i0 integral, estimated from stars (only for flag 1)')
    zptSchema.addField('fgcmR10', type=np.float64,
                       doc='Retrieved i10 integral, estimated from stars (only for flag 1)')
    zptSchema.addField('fgcmGry', type=np.float64,
                       doc='Estimated gray extinction relative to atmospheric solution; '
                       'only for fgcmFlag <= 4 (see fgcmFlag) ')
    zptSchema.addField('fgcmDeltaChrom', type=np.float64,
                       doc='Mean chromatic correction for stars in this ccd; '
                       'only for fgcmFlag <= 4 (see fgcmFlag)')
    zptSchema.addField('fgcmZptVar', type=np.float64, doc='Variance of zeropoint over ccd')
    zptSchema.addField('fgcmTilings', type=np.float64,
                       doc='Number of photometric tilings used for solution for ccd')
    zptSchema.addField('fgcmFpGry', type=np.float64,
                       doc='Average gray extinction over the full focal plane '
                       '(same for all ccds in a visit)')
    zptSchema.addField('fgcmFpGryBlue', type=np.float64,
                       doc='Average gray extinction over the full focal plane '
                       'for 25% bluest stars')
    zptSchema.addField('fgcmFpGryBlueErr', type=np.float64,
                       doc='Error on Average gray extinction over the full focal plane '
                       'for 25% bluest stars')
    zptSchema.addField('fgcmFpGryRed', type=np.float64,
                       doc='Average gray extinction over the full focal plane '
                       'for 25% reddest stars')
    zptSchema.addField('fgcmFpGryRedErr', type=np.float64,
                       doc='Error on Average gray extinction over the full focal plane '
                       'for 25% reddest stars')
    zptSchema.addField('fgcmFpVar', type=np.float64,
                       doc='Variance of gray extinction over the full focal plane '
                       '(same for all ccds in a visit)')
    zptSchema.addField('fgcmDust', type=np.float64,
                       doc='Gray dust extinction from the primary/corrector'
                       'at the time of the exposure')
    zptSchema.addField('fgcmFlat', type=np.float64, doc='Superstarflat illumination correction')
    zptSchema.addField('fgcmAperCorr', type=np.float64, doc='Aperture correction estimated by fgcm')
    zptSchema.addField('fgcmDeltaMagBkg', type=np.float64,
                       doc=('Local background correction from brightest percentile '
                            '(value set by deltaMagBkgOffsetPercentile) calibration '
                            'stars.'))
    zptSchema.addField('exptime', type=np.float32, doc='Exposure time')
    zptSchema.addField('filtername', type=str, size=30, doc='Filter name')
 
    return zptSchema
 
 

translateFgcmLut()

lsst.fgcmcal.utilities.translateFgcmLut	(		lutCat,
			physicalFilterMap )

Translate the FGCM look-up-table into an fgcm-compatible object

Parameters
----------
lutCat: `lsst.afw.table.BaseCatalog`
   Catalog describing the FGCM look-up table
physicalFilterMap: `dict`
   Physical filter to band mapping

Returns
-------
fgcmLut: `lsst.fgcm.FgcmLut`
   Lookup table for FGCM
lutIndexVals: `numpy.ndarray`
   Numpy array with LUT index information for FGCM
lutStd: `numpy.ndarray`
   Numpy array with LUT standard throughput values for FGCM

Notes
-----
After running this code, it is wise to `del lutCat` to clear the memory.

Definition at line 257 of file utilities.py.

def translateFgcmLut(lutCat, physicalFilterMap):
    """
    Translate the FGCM look-up-table into an fgcm-compatible object
 
    Parameters
    ----------
    lutCat: `lsst.afw.table.BaseCatalog`
       Catalog describing the FGCM look-up table
    physicalFilterMap: `dict`
       Physical filter to band mapping
 
    Returns
    -------
    fgcmLut: `lsst.fgcm.FgcmLut`
       Lookup table for FGCM
    lutIndexVals: `numpy.ndarray`
       Numpy array with LUT index information for FGCM
    lutStd: `numpy.ndarray`
       Numpy array with LUT standard throughput values for FGCM
 
    Notes
    -----
    After running this code, it is wise to `del lutCat` to clear the memory.
    """
 
    # first we need the lutIndexVals
    lutFilterNames = np.array(lutCat[0]['physicalFilters'].split(','), dtype='U')
    lutStdFilterNames = np.array(lutCat[0]['stdPhysicalFilters'].split(','), dtype='U')
 
    # Note that any discrepancies between config values will raise relevant
    # exceptions in the FGCM code.
 
    lutIndexVals = np.zeros(1, dtype=[('FILTERNAMES', lutFilterNames.dtype.str,
                                       lutFilterNames.size),
                                      ('STDFILTERNAMES', lutStdFilterNames.dtype.str,
                                       lutStdFilterNames.size),
                                      ('PMB', 'f8', lutCat[0]['pmb'].size),
                                      ('PMBFACTOR', 'f8', lutCat[0]['pmbFactor'].size),
                                      ('PMBELEVATION', 'f8'),
                                      ('LAMBDANORM', 'f8'),
                                      ('PWV', 'f8', lutCat[0]['pwv'].size),
                                      ('O3', 'f8', lutCat[0]['o3'].size),
                                      ('TAU', 'f8', lutCat[0]['tau'].size),
                                      ('ALPHA', 'f8', lutCat[0]['alpha'].size),
                                      ('ZENITH', 'f8', lutCat[0]['zenith'].size),
                                      ('NCCD', 'i4')])
 
    lutIndexVals['FILTERNAMES'][:] = lutFilterNames
    lutIndexVals['STDFILTERNAMES'][:] = lutStdFilterNames
    lutIndexVals['PMB'][:] = lutCat[0]['pmb']
    lutIndexVals['PMBFACTOR'][:] = lutCat[0]['pmbFactor']
    lutIndexVals['PMBELEVATION'] = lutCat[0]['pmbElevation']
    lutIndexVals['LAMBDANORM'] = lutCat[0]['lambdaNorm']
    lutIndexVals['PWV'][:] = lutCat[0]['pwv']
    lutIndexVals['O3'][:] = lutCat[0]['o3']
    lutIndexVals['TAU'][:] = lutCat[0]['tau']
    lutIndexVals['ALPHA'][:] = lutCat[0]['alpha']
    lutIndexVals['ZENITH'][:] = lutCat[0]['zenith']
    lutIndexVals['NCCD'] = lutCat[0]['nCcd']
 
    # now we need the Standard Values
    lutStd = np.zeros(1, dtype=[('PMBSTD', 'f8'),
                                ('PWVSTD', 'f8'),
                                ('O3STD', 'f8'),
                                ('TAUSTD', 'f8'),
                                ('ALPHASTD', 'f8'),
                                ('ZENITHSTD', 'f8'),
                                ('LAMBDARANGE', 'f8', 2),
                                ('LAMBDASTEP', 'f8'),
                                ('LAMBDASTD', 'f8', lutFilterNames.size),
                                ('LAMBDASTDFILTER', 'f8', lutStdFilterNames.size),
                                ('I0STD', 'f8', lutFilterNames.size),
                                ('I1STD', 'f8', lutFilterNames.size),
                                ('I10STD', 'f8', lutFilterNames.size),
                                ('I2STD', 'f8', lutFilterNames.size),
                                ('LAMBDAB', 'f8', lutFilterNames.size),
                                ('ATMLAMBDA', 'f8', lutCat[0]['atmLambda'].size),
                                ('ATMSTDTRANS', 'f8', lutCat[0]['atmStdTrans'].size)])
    lutStd['PMBSTD'] = lutCat[0]['pmbStd']
    lutStd['PWVSTD'] = lutCat[0]['pwvStd']
    lutStd['O3STD'] = lutCat[0]['o3Std']
    lutStd['TAUSTD'] = lutCat[0]['tauStd']
    lutStd['ALPHASTD'] = lutCat[0]['alphaStd']
    lutStd['ZENITHSTD'] = lutCat[0]['zenithStd']
    lutStd['LAMBDARANGE'][:] = lutCat[0]['lambdaRange'][:]
    lutStd['LAMBDASTEP'] = lutCat[0]['lambdaStep']
    lutStd['LAMBDASTD'][:] = lutCat[0]['lambdaStd']
    lutStd['LAMBDASTDFILTER'][:] = lutCat[0]['lambdaStdFilter']
    lutStd['I0STD'][:] = lutCat[0]['i0Std']
    lutStd['I1STD'][:] = lutCat[0]['i1Std']
    lutStd['I10STD'][:] = lutCat[0]['i10Std']
    lutStd['I2STD'][:] = lutCat[0]['i2Std']
    lutStd['LAMBDAB'][:] = lutCat[0]['lambdaB']
    lutStd['ATMLAMBDA'][:] = lutCat[0]['atmLambda'][:]
    lutStd['ATMSTDTRANS'][:] = lutCat[0]['atmStdTrans'][:]
 
    lutTypes = [row['luttype'] for row in lutCat]
 
    # And the flattened look-up-table
    lutFlat = np.zeros(lutCat[0]['lut'].size, dtype=[('I0', 'f4'),
                                                     ('I1', 'f4')])
 
    lutFlat['I0'][:] = lutCat[lutTypes.index('I0')]['lut'][:]
    lutFlat['I1'][:] = lutCat[lutTypes.index('I1')]['lut'][:]
 
    lutDerivFlat = np.zeros(lutCat[0]['lut'].size, dtype=[('D_LNPWV', 'f4'),
                                                          ('D_O3', 'f4'),
                                                          ('D_LNTAU', 'f4'),
                                                          ('D_ALPHA', 'f4'),
                                                          ('D_SECZENITH', 'f4'),
                                                          ('D_LNPWV_I1', 'f4'),
                                                          ('D_O3_I1', 'f4'),
                                                          ('D_LNTAU_I1', 'f4'),
                                                          ('D_ALPHA_I1', 'f4'),
                                                          ('D_SECZENITH_I1', 'f4')])
 
    for name in lutDerivFlat.dtype.names:
        lutDerivFlat[name][:] = lutCat[lutTypes.index(name)]['lut'][:]
 
    # The fgcm.FgcmLUT() class copies all the LUT information into special
    # shared memory objects that will not blow up the memory usage when used
    # with python multiprocessing.  Once all the numbers are copied, the
    # references to the temporary objects (lutCat, lutFlat, lutDerivFlat)
    # will fall out of scope and can be cleaned up by the garbage collector.
    fgcmLut = fgcm.FgcmLUT(lutIndexVals, lutFlat, lutDerivFlat, lutStd,
                           filterToBand=physicalFilterMap)
 
    return fgcmLut, lutIndexVals, lutStd
 
 

translateVisitCatalog()

lsst.fgcmcal.utilities.translateVisitCatalog

(

visitCat

)

Translate the FGCM visit catalog to an fgcm-compatible object

Parameters
----------
visitCat: `lsst.afw.table.BaseCatalog`
   FGCM visitCat from `lsst.fgcmcal.FgcmBuildStarsTask`

Returns
-------
fgcmExpInfo: `numpy.ndarray`
   Numpy array for visit information for FGCM

Notes
-----
After running this code, it is wise to `del visitCat` to clear the memory.

Definition at line 387 of file utilities.py.

def translateVisitCatalog(visitCat):
    """
    Translate the FGCM visit catalog to an fgcm-compatible object
 
    Parameters
    ----------
    visitCat: `lsst.afw.table.BaseCatalog`
       FGCM visitCat from `lsst.fgcmcal.FgcmBuildStarsTask`
 
    Returns
    -------
    fgcmExpInfo: `numpy.ndarray`
       Numpy array for visit information for FGCM
 
    Notes
    -----
    After running this code, it is wise to `del visitCat` to clear the memory.
    """
 
    fgcmExpInfo = np.zeros(len(visitCat), dtype=[('VISIT', 'i8'),
                                                 ('MJD', 'f8'),
                                                 ('EXPTIME', 'f8'),
                                                 ('PSFFWHM', 'f8'),
                                                 ('DELTA_APER', 'f8'),
                                                 ('SKYBACKGROUND', 'f8'),
                                                 ('DEEPFLAG', 'i2'),
                                                 ('TELHA', 'f8'),
                                                 ('TELRA', 'f8'),
                                                 ('TELDEC', 'f8'),
                                                 ('TELROT', 'f8'),
                                                 ('PMB', 'f8'),
                                                 ('FILTERNAME', 'a50')])
    fgcmExpInfo['VISIT'][:] = visitCat['visit']
    fgcmExpInfo['MJD'][:] = visitCat['mjd']
    fgcmExpInfo['EXPTIME'][:] = visitCat['exptime']
    fgcmExpInfo['DEEPFLAG'][:] = visitCat['deepFlag']
    fgcmExpInfo['TELHA'][:] = visitCat['telha']
    fgcmExpInfo['TELRA'][:] = visitCat['telra']
    fgcmExpInfo['TELDEC'][:] = visitCat['teldec']
    fgcmExpInfo['TELROT'][:] = visitCat['telrot']
    fgcmExpInfo['PMB'][:] = visitCat['pmb']
    fgcmExpInfo['PSFFWHM'][:] = visitCat['psfFwhm']
    fgcmExpInfo['DELTA_APER'][:] = visitCat['deltaAper']
    fgcmExpInfo['SKYBACKGROUND'][:] = visitCat['skyBackground']
    # Note that we have to go through asAstropy() to get a string
    #  array out of an afwTable.  This is faster than a row-by-row loop.
    fgcmExpInfo['FILTERNAME'][:] = visitCat.asAstropy()['physicalFilter']
 
    return fgcmExpInfo
 
 

Variable Documentation

FGCM_CCD_FIELD

str lsst.fgcmcal.utilities.FGCM_CCD_FIELD = 'DETECTOR'

Definition at line 43 of file utilities.py.

FGCM_EXP_FIELD

str lsst.fgcmcal.utilities.FGCM_EXP_FIELD = 'VISIT'

Definition at line 42 of file utilities.py.

FGCM_ILLEGAL_VALUE

float lsst.fgcmcal.utilities.FGCM_ILLEGAL_VALUE = -9999.0

Definition at line 44 of file utilities.py.