lsst.jointcal.jointcal Namespace Reference

Classes
class	JointcalConfig
class	JointcalInputData
class	JointcalTask
class	JointcalTaskConnections

Functions
def	add_measurement (job, name, value)
def	lookupStaticCalibrations (datasetType, registry, quantumDataId, collections)
def	lookupVisitRefCats (datasetType, registry, quantumDataId, collections)
def	writeModel (model, filename, log)
def	make_schema_table ()
def	get_sourceTable_visit_columns (inColumns, config, sourceSelector)
def	extract_detector_catalog_from_visit_catalog (table, visitCatalog, detectorId, ixxColumns, sourceFluxType, log)

Variables
	Photometry = collections.namedtuple('Photometry', ('fit', 'model'))
	Astrometry = collections.namedtuple('Astrometry', ('fit', 'model', 'sky_to_tan_projection'))

Function Documentation

add_measurement()

def lsst.jointcal.jointcal.add_measurement	(		job,
			name,
			value
	)

Definition at line 56 of file jointcal.py.

def add_measurement(job, name, value):
    meas = Measurement(job.metrics[name], value)
    job.measurements.insert(meas)
 
 

extract_detector_catalog_from_visit_catalog()

def lsst.jointcal.jointcal.extract_detector_catalog_from_visit_catalog	(		table,
			visitCatalog,
			detectorId,
			ixxColumns,
			sourceFluxType,
			log
	)

Return an afw SourceCatalog extracted from a visit-level dataframe,
limited to just one detector.

Parameters
----------
table : `lsst.afw.table.SourceTable`
    Table factory to use to make the SourceCatalog that will be
    populated with data from ``visitCatalog``.
visitCatalog : `pandas.DataFrame`
    DataFrame to extract a detector catalog from.
detectorId : `int`
    Numeric id of the detector to extract from ``visitCatalog``.
ixxColumns : `list` [`str`]
    Names of the ixx/iyy/ixy columns in the catalog.
sourceFluxType : `str`
    Name of the catalog field to load instFluxes from.
log : `logging.Logger`
    Logging instance to log to.

Returns
-------
catalog : `lsst.afw.table.SourceCatalog`, or `None`
    Detector-level catalog extracted from ``visitCatalog``, or `None`
    if there was no data to load.

Definition at line 1611 of file jointcal.py.

                                                ixxColumns, sourceFluxType, log):
    """Return an afw SourceCatalog extracted from a visit-level dataframe,
    limited to just one detector.
 
    Parameters
    ----------
    table : `lsst.afw.table.SourceTable`
        Table factory to use to make the SourceCatalog that will be
        populated with data from ``visitCatalog``.
    visitCatalog : `pandas.DataFrame`
        DataFrame to extract a detector catalog from.
    detectorId : `int`
        Numeric id of the detector to extract from ``visitCatalog``.
    ixxColumns : `list` [`str`]
        Names of the ixx/iyy/ixy columns in the catalog.
    sourceFluxType : `str`
        Name of the catalog field to load instFluxes from.
    log : `logging.Logger`
        Logging instance to log to.
 
    Returns
    -------
    catalog : `lsst.afw.table.SourceCatalog`, or `None`
        Detector-level catalog extracted from ``visitCatalog``, or `None`
        if there was no data to load.
    """
    # map from dataFrame column to afw table column
    mapping = {'x': 'centroid_x',
               'y': 'centroid_y',
               'xErr': 'centroid_xErr',
               'yErr': 'centroid_yErr',
               ixxColumns[0]: 'shape_xx',
               ixxColumns[1]: 'shape_yy',
               ixxColumns[2]: 'shape_xy',
               f'{sourceFluxType}_instFlux': 'flux_instFlux',
               f'{sourceFluxType}_instFluxErr': 'flux_instFluxErr',
               }
 
    catalog = lsst.afw.table.SourceCatalog(table)
    matched = visitCatalog['detector'] == detectorId
    n = sum(matched)
    if n == 0:
        return None
    catalog.resize(sum(matched))
    view = visitCatalog.loc[matched]
    catalog['id'] = view.index
    for dfCol, afwCol in mapping.items():
        catalog[afwCol] = view[dfCol]
 
    log.debug("%d sources selected in visit %d detector %d",
              len(catalog),
              view['visit'].iloc[0],  # all visits in this catalog are the same, so take the first
              detectorId)
    return catalog

get_sourceTable_visit_columns()

def lsst.jointcal.jointcal.get_sourceTable_visit_columns	(		inColumns,
			config,
			sourceSelector
	)

Get the sourceTable_visit columns to load from the catalogs.

Parameters
----------
inColumns : `list`
    List of columns known to be available in the sourceTable_visit.
config : `JointcalConfig`
    A filled-in config to to help define column names.
sourceSelector : `lsst.meas.algorithms.BaseSourceSelectorTask`
    A configured source selector to define column names to load.

Returns
-------
columns : `list`
    List of columns to read from sourceTable_visit.
ixxColumns : `list`
    Name of the ixx/iyy/ixy columns.

Definition at line 1565 of file jointcal.py.

def get_sourceTable_visit_columns(inColumns, config, sourceSelector):
    """
    Get the sourceTable_visit columns to load from the catalogs.
 
    Parameters
    ----------
    inColumns : `list`
        List of columns known to be available in the sourceTable_visit.
    config : `JointcalConfig`
        A filled-in config to to help define column names.
    sourceSelector : `lsst.meas.algorithms.BaseSourceSelectorTask`
        A configured source selector to define column names to load.
 
    Returns
    -------
    columns : `list`
        List of columns to read from sourceTable_visit.
    ixxColumns : `list`
        Name of the ixx/iyy/ixy columns.
    """
    columns = ['visit', 'detector',
               'sourceId', 'x', 'xErr', 'y', 'yErr',
               config.sourceFluxType + '_instFlux', config.sourceFluxType + '_instFluxErr']
 
    if 'ixx' in inColumns:
        # New columns post-DM-31825
        ixxColumns = ['ixx', 'iyy', 'ixy']
    else:
        # Old columns pre-DM-31825
        ixxColumns = ['Ixx', 'Iyy', 'Ixy']
    columns.extend(ixxColumns)
 
    if sourceSelector.config.doFlags:
        columns.extend(sourceSelector.config.flags.bad)
    if sourceSelector.config.doUnresolved:
        columns.append(sourceSelector.config.unresolved.name)
    if sourceSelector.config.doIsolated:
        columns.append(sourceSelector.config.isolated.parentName)
        columns.append(sourceSelector.config.isolated.nChildName)
    if sourceSelector.config.doRequireFiniteRaDec:
        columns.append(sourceSelector.config.requireFiniteRaDec.raColName)
        columns.append(sourceSelector.config.requireFiniteRaDec.decColName)
 
    return columns, ixxColumns
 
 

lookupStaticCalibrations()

def lsst.jointcal.jointcal.lookupStaticCalibrations	(		datasetType,
			registry,
			quantumDataId,
			collections
	)

Lookup function that asserts/hopes that a static calibration dataset
exists in a particular collection, since this task can't provide a single
date/time to use to search for one properly.

This is mostly useful for the ``camera`` dataset, in cases where the task's
quantum dimensions do *not* include something temporal, like ``exposure``
or ``visit``.

Parameters
----------
datasetType : `lsst.daf.butler.DatasetType`
    Type of dataset being searched for.
registry : `lsst.daf.butler.Registry`
    Data repository registry to search.
quantumDataId : `lsst.daf.butler.DataCoordinate`
    Data ID of the quantum this camera should match.
collections : `Iterable` [ `str` ]
    Collections that should be searched - but this lookup function works
    by ignoring this in favor of a more-or-less hard-coded value.

Returns
-------
refs : `Iterator` [ `lsst.daf.butler.DatasetRef` ]
    Iterator over dataset references; should have only one element.

Notes
-----
This implementation duplicates one in fgcmcal, and is at least quite
similar to another in cp_pipe.  This duplicate has the most documentation.
Fixing this is DM-29661.

Definition at line 61 of file jointcal.py.

def lookupStaticCalibrations(datasetType, registry, quantumDataId, collections):
    """Lookup function that asserts/hopes that a static calibration dataset
    exists in a particular collection, since this task can't provide a single
    date/time to use to search for one properly.
 
    This is mostly useful for the ``camera`` dataset, in cases where the task's
    quantum dimensions do *not* include something temporal, like ``exposure``
    or ``visit``.
 
    Parameters
    ----------
    datasetType : `lsst.daf.butler.DatasetType`
        Type of dataset being searched for.
    registry : `lsst.daf.butler.Registry`
        Data repository registry to search.
    quantumDataId : `lsst.daf.butler.DataCoordinate`
        Data ID of the quantum this camera should match.
    collections : `Iterable` [ `str` ]
        Collections that should be searched - but this lookup function works
        by ignoring this in favor of a more-or-less hard-coded value.
 
    Returns
    -------
    refs : `Iterator` [ `lsst.daf.butler.DatasetRef` ]
        Iterator over dataset references; should have only one element.
 
    Notes
    -----
    This implementation duplicates one in fgcmcal, and is at least quite
    similar to another in cp_pipe.  This duplicate has the most documentation.
    Fixing this is DM-29661.
    """
    instrument = Instrument.fromName(quantumDataId["instrument"], registry)
    unboundedCollection = instrument.makeUnboundedCalibrationRunName()
    return registry.queryDatasets(datasetType,
                                  dataId=quantumDataId,
                                  collections=[unboundedCollection],
                                  findFirst=True)
 
 

lookupVisitRefCats()

def lsst.jointcal.jointcal.lookupVisitRefCats	(		datasetType,
			registry,
			quantumDataId,
			collections
	)

Lookup function that finds all refcats for all visits that overlap a
tract, rather than just the refcats that directly overlap the tract.

Parameters
----------
datasetType : `lsst.daf.butler.DatasetType`
    Type of dataset being searched for.
registry : `lsst.daf.butler.Registry`
    Data repository registry to search.
quantumDataId : `lsst.daf.butler.DataCoordinate`
    Data ID of the quantum; expected to be something we can use as a
    constraint to query for overlapping visits.
collections : `Iterable` [ `str` ]
    Collections to search.

Returns
-------
refs : `Iterator` [ `lsst.daf.butler.DatasetRef` ]
    Iterator over refcat references.

Definition at line 101 of file jointcal.py.

def lookupVisitRefCats(datasetType, registry, quantumDataId, collections):
    """Lookup function that finds all refcats for all visits that overlap a
    tract, rather than just the refcats that directly overlap the tract.
 
    Parameters
    ----------
    datasetType : `lsst.daf.butler.DatasetType`
        Type of dataset being searched for.
    registry : `lsst.daf.butler.Registry`
        Data repository registry to search.
    quantumDataId : `lsst.daf.butler.DataCoordinate`
        Data ID of the quantum; expected to be something we can use as a
        constraint to query for overlapping visits.
    collections : `Iterable` [ `str` ]
        Collections to search.
 
    Returns
    -------
    refs : `Iterator` [ `lsst.daf.butler.DatasetRef` ]
        Iterator over refcat references.
    """
    refs = set()
    # Use .expanded() on the query methods below because we need data IDs with
    # regions, both in the outer loop over visits (queryDatasets will expand
    # any data ID we give it, but doing it up-front in bulk is much more
    # efficient) and in the data IDs of the DatasetRefs this function yields
    # (because the RefCatLoader relies on them to do some of its own
    # filtering).
    for visit_data_id in set(registry.queryDataIds("visit", dataId=quantumDataId).expanded()):
        refs.update(
            registry.queryDatasets(
                datasetType,
                collections=collections,
                dataId=visit_data_id,
                findFirst=True,
            ).expanded()
        )
    yield from refs
 
 

make_schema_table()

def lsst.jointcal.jointcal.make_schema_table

(

)

Return an afw SourceTable to use as a base for creating the
SourceCatalog to insert values from the dataFrame into.

Returns
-------
table : `lsst.afw.table.SourceTable`
    Table with schema and slots to use to make SourceCatalogs.

Definition at line 1540 of file jointcal.py.

def make_schema_table():
    """Return an afw SourceTable to use as a base for creating the
    SourceCatalog to insert values from the dataFrame into.
 
    Returns
    -------
    table : `lsst.afw.table.SourceTable`
        Table with schema and slots to use to make SourceCatalogs.
    """
    schema = lsst.afw.table.SourceTable.makeMinimalSchema()
    schema.addField("centroid_x", "D")
    schema.addField("centroid_y", "D")
    schema.addField("centroid_xErr", "F")
    schema.addField("centroid_yErr", "F")
    schema.addField("shape_xx", "D")
    schema.addField("shape_yy", "D")
    schema.addField("shape_xy", "D")
    schema.addField("flux_instFlux", "D")
    schema.addField("flux_instFluxErr", "D")
    table = lsst.afw.table.SourceTable.make(schema)
    table.defineCentroid("centroid")
    table.defineShape("shape")
    return table
 
 

writeModel()

def lsst.jointcal.jointcal.writeModel	(		model,
			filename,
			log
	)

Write model to outfile.

Definition at line 546 of file jointcal.py.

def writeModel(model, filename, log):
    """Write model to outfile."""
    with open(filename, "w") as file:
        file.write(repr(model))
    log.info("Wrote %s to file: %s", model, filename)
 
 
@dataclasses.dataclass

Variable Documentation

Astrometry

lsst.jointcal.jointcal.Astrometry = collections.namedtuple('Astrometry', ('fit', 'model', 'sky_to_tan_projection'))

Definition at line 52 of file jointcal.py.

Photometry

lsst.jointcal.jointcal.Photometry = collections.namedtuple('Photometry', ('fit', 'model'))

Definition at line 51 of file jointcal.py.