Public Member Functions
	__init__ (self, schema, dataIdFormat, coordField="coord", idField="id", radius=None, RecordClass=SourceRecord)

	makeRecord (self, inputRecord, dataId, objId)

	add (self, catalog, dataId)

	finish (self, removeAmbiguous=True)

Public Attributes
	radius

	mapper

	coordKey

	idKey

	dataIdKeys

	objectKey

	result

	reference

	ambiguous

	table

	nextObjId

Detailed Description

Initialize a multi-catalog match.

Parameters
----------
schema : `lsst.afw.table.Schema`
    Schema shared by all catalogs to be included in the match.
dataIdFormat : `dict`
    Set of name: type for all data ID keys (e.g. {"visit":int,
    "ccd":int}).
coordField : `str`, optional
    Prefix for _ra and _dec fields that contain the
    coordinates to use for the match.
idField : `str`, optional
    Name of the field in schema that contains unique object
    IDs.
radius : `lsst.geom.Angle`, optional
    Maximum separation for a match.  Defaults to 0.5 arcseconds.
RecordClass : `lsst.afw.table.BaseRecord`
    Type of record to expect in catalogs to be matched.

Definition at line 30 of file multiMatch.py.

Constructor & Destructor Documentation

◆ init()

lsst.afw.table.multiMatch.MultiMatch.__init__	(	self,
		schema,
		dataIdFormat,
		coordField = "coord",
		idField = "id",
		radius = None,
		RecordClass = SourceRecord )

Definition at line 52 of file multiMatch.py.

                 RecordClass=SourceRecord):
        if radius is None:
            radius = 0.5*lsst.geom.arcseconds
        elif not isinstance(radius, lsst.geom.Angle):
            raise ValueError("'radius' argument must be an Angle")
        self.radius = radius
        self.mapper = SchemaMapper(schema)
        self.mapper.addMinimalSchema(schema, True)
        self.coordKey = CoordKey(schema[coordField])
        self.idKey = schema.find(idField).key
        self.dataIdKeys = {}
        outSchema = self.mapper.editOutputSchema()
        outSchema.setAliasMap(self.mapper.getInputSchema().getAliasMap())
        self.objectKey = outSchema.addField(
            "object", type=numpy.int64, doc="Unique ID for joined sources")
        for name, dataType in dataIdFormat.items():
            self.dataIdKeys[name] = outSchema.addField(
                name, type=dataType, doc="'%s' data ID component")
        # self.result will be a catalog containing the union of all matched records, with an 'object' ID
        # column that can be used to group matches.  Sources that have ambiguous matches may appear
        # multiple times.
        self.result = None
        # self.reference will be a subset of self.result, with exactly one record for each group of matches
        # (we'll use the one from the first catalog matched into this group)
        # We'll use this to match against each subsequent catalog.
        self.reference = None
        # A set of ambiguous objects that we may want to ultimately remove from
        # the final merged catalog.
        self.ambiguous = set()
        # Table used to allocate new records for the ouput catalog.
        self.table = RecordClass.Table.make(self.mapper.getOutputSchema())
        # Counter used to assign the next object ID
        self.nextObjId = 1
 

Member Function Documentation

◆ add()

lsst.afw.table.multiMatch.MultiMatch.add	(	self,
		catalog,
		dataId )

Add a new catalog to the match, corresponding to the given data ID.
The new catalog is appended to the `self.result` and
`self.reference` catalogs.

Parameters
----------
catalog : `lsst.afw.table.base.Catalog`
    Catalog to be added to the match result.
dataId : `DataId` or `dict`
    Data id for the catalog to be added.

Definition at line 111 of file multiMatch.py.

    def add(self, catalog, dataId):
        """Add a new catalog to the match, corresponding to the given data ID.
        The new catalog is appended to the `self.result` and
        `self.reference` catalogs.
 
        Parameters
        ----------
        catalog : `lsst.afw.table.base.Catalog`
            Catalog to be added to the match result.
        dataId : `DataId` or `dict`
            Data id for the catalog to be added.
        """
        if self.result is None:
            self.result = self.table.Catalog(self.table)
            for record in catalog:
                self.result.append(self.makeRecord(
                    record, dataId, objId=self.nextObjId))
                self.nextObjId += 1
            self.reference = self.result.copy(deep=False)
            return
        catalog.sort(self.idKey)  # pre-sort for speedy by-id access later.
        # Will remove from this set as objects are matched.
        unmatchedIds = {record.get(self.idKey) for record in catalog}
        # Temporary dict mapping new source ID to a set of associated objects.
        newToObj = {}
        matches = lsst.afw.table.matchRaDec(self.reference, catalog, self.radius)
        matchedRefIds = set()
        matchedCatIds = set()
        for refRecord, newRecord, distance in matches:
            objId = refRecord.get(self.objectKey)
            if objId in matchedRefIds:
                # We've already matched this object against another new source,
                # mark it as ambiguous.
                self.ambiguous.add(objId)
            matchedRefIds.add(objId)
            if newRecord.get(self.idKey) in matchedCatIds:
                # We've already matched this new source to one or more other objects
                # Mark all involved objects as ambiguous
                self.ambiguous.add(objId)
                self.ambiguous |= newToObj.get(newRecord.get(self.idKey), set())
            matchedCatIds.add(newRecord.get(self.idKey))
            unmatchedIds.discard(newRecord.get(self.idKey))
            # Populate the newToObj dict (setdefault trick is an idiom for
            # appending to a dict-of-sets)
            newToObj.setdefault(newRecord.get(self.idKey), set()).add(objId)
            # Add a new result record for this match.
            self.result.append(self.makeRecord(newRecord, dataId, objId))
        # Add any unmatched sources from the new catalog as new objects to both
        # the joined result catalog and the reference catalog.
        for objId in unmatchedIds:
            newRecord = catalog.find(objId, self.idKey)
            resultRecord = self.makeRecord(newRecord, dataId, self.nextObjId)
            self.nextObjId += 1
            self.result.append(resultRecord)
            self.reference.append(resultRecord)
 

◆ finish()

lsst.afw.table.multiMatch.MultiMatch.finish	(		self,
			removeAmbiguous = True )

Return the final match catalog, after sorting it by object, copying
it to ensure contiguousness, and optionally removing ambiguous
matches.

After calling finish(), the in-progress state of the matcher
is returned to the state it was just after construction, with
the exception of the object ID counter (which is not reset).

Parameters
----------
removeAmbiguous : `bool`, optional
    Should ambiguous matches be removed from the match
    catalog?  Defaults to True.

Returns
-------
result : `lsst.afw.table.base.Catalog`
    Final match catalog, sorted by object.

Definition at line 167 of file multiMatch.py.

    def finish(self, removeAmbiguous=True):
        """Return the final match catalog, after sorting it by object, copying
        it to ensure contiguousness, and optionally removing ambiguous
        matches.
 
        After calling finish(), the in-progress state of the matcher
        is returned to the state it was just after construction, with
        the exception of the object ID counter (which is not reset).
 
        Parameters
        ----------
        removeAmbiguous : `bool`, optional
            Should ambiguous matches be removed from the match
            catalog?  Defaults to True.
 
        Returns
        -------
        result : `lsst.afw.table.base.Catalog`
            Final match catalog, sorted by object.
        """
        if removeAmbiguous:
            result = self.table.Catalog(self.table)
            for record in self.result:
                if record.get(self.objectKey) not in self.ambiguous:
                    result.append(record)
        else:
            result = self.result
        result.sort(self.objectKey)
        result = result.copy(deep=True)
        self.result = None
        self.reference = None
        self.ambiguous = set()
        return result
 
 

◆ makeRecord()

lsst.afw.table.multiMatch.MultiMatch.makeRecord	(	self,
		inputRecord,
		dataId,
		objId )

Create a new result record from the given input record, using the
given data ID and object ID to fill in additional columns.

Parameters
----------
inputRecord : `lsst.afw.table.source.sourceRecord`
    Record to use as the reference for the new result.
dataId : `DataId` or `dict`
    Data id describing the data.
objId : `int`
    Object id of the object to be added.

Returns
-------
outputRecord : `lsst.afw.table.source.sourceRecord`
    Newly generated record.

Definition at line 87 of file multiMatch.py.

    def makeRecord(self, inputRecord, dataId, objId):
        """Create a new result record from the given input record, using the
        given data ID and object ID to fill in additional columns.
 
        Parameters
        ----------
        inputRecord : `lsst.afw.table.source.sourceRecord`
            Record to use as the reference for the new result.
        dataId : `DataId` or `dict`
            Data id describing the data.
        objId : `int`
            Object id of the object to be added.
 
        Returns
        -------
        outputRecord : `lsst.afw.table.source.sourceRecord`
            Newly generated record.
        """
        outputRecord = self.table.copyRecord(inputRecord, self.mapper)
        for name, key in self.dataIdKeys.items():
            outputRecord.set(key, dataId[name])
        outputRecord.set(self.objectKey, objId)
        return outputRecord
 

Member Data Documentation

◆ ambiguous

lsst.afw.table.multiMatch.MultiMatch.ambiguous

Definition at line 81 of file multiMatch.py.

◆ coordKey

lsst.afw.table.multiMatch.MultiMatch.coordKey

Definition at line 61 of file multiMatch.py.

◆ dataIdKeys

lsst.afw.table.multiMatch.MultiMatch.dataIdKeys

Definition at line 63 of file multiMatch.py.

◆ idKey

lsst.afw.table.multiMatch.MultiMatch.idKey

Definition at line 62 of file multiMatch.py.

◆ mapper

lsst.afw.table.multiMatch.MultiMatch.mapper

Definition at line 59 of file multiMatch.py.

◆ nextObjId

lsst.afw.table.multiMatch.MultiMatch.nextObjId

Definition at line 85 of file multiMatch.py.

◆ objectKey

lsst.afw.table.multiMatch.MultiMatch.objectKey

Definition at line 66 of file multiMatch.py.

◆ radius

lsst.afw.table.multiMatch.MultiMatch.radius

Definition at line 58 of file multiMatch.py.

◆ reference

lsst.afw.table.multiMatch.MultiMatch.reference

Definition at line 78 of file multiMatch.py.

◆ result

lsst.afw.table.multiMatch.MultiMatch.result

Definition at line 74 of file multiMatch.py.

◆ table

lsst.afw.table.multiMatch.MultiMatch.table

Definition at line 83 of file multiMatch.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/python/lsst/afw/table/multiMatch.py

Public Member Functions

Public Attributes