lsst.pipe.drivers.constructCalibs Namespace Reference

Classes
class	BiasConfig
class	BiasTask
class	CalibArgumentParser
class	CalibCombineConfig
class	CalibCombineTask
class	CalibConfig
class	CalibIdAction
class	CalibStatsConfig
class	CalibStatsTask
class	CalibTask
	Base class for constructing calibs. More...
class	CalibTaskRunner
class	DarkConfig
class	DarkTask
class	FlatConfig
class	FlatTask
class	FringeConfig
class	FringeTask
class	SkyConfig
class	SkyTask

Functions
def	getSize (dimList)
def	dictToTuple (dict_, keys)
	Return a tuple of specific values from a dict. More...
def	getCcdIdListFromExposures (expRefList, level="sensor", ccdKeys=["ccd"])
	Determine a list of CCDs from exposure references. More...
def	mapToMatrix (pool, func, ccdIdLists, args, kwargs)

Function Documentation

dictToTuple()

def lsst.pipe.drivers.constructCalibs.dictToTuple	(		dict_,
			keys
	)

Return a tuple of specific values from a dict.

This provides a hashable representation of the dict from certain keywords. This can be useful for creating e.g., a tuple of the values in the DataId that identify the CCD.

Parameters

dict_	dict to parse
keys	keys to extract (order is important)

Returns

tuple of values

Definition at line 189 of file constructCalibs.py.

def dictToTuple(dict_, keys):
    """!Return a tuple of specific values from a dict

    This provides a hashable representation of the dict from certain keywords.
    This can be useful for creating e.g., a tuple of the values in the DataId
    that identify the CCD.

    @param dict_  dict to parse
    @param keys  keys to extract (order is important)
    @return tuple of values
    """
    return tuple(dict_[k] for k in keys)

getCcdIdListFromExposures()

def lsst.pipe.drivers.constructCalibs.getCcdIdListFromExposures	(		expRefList,
			level = "sensor",
			ccdKeys = ["ccd"]
	)

Determine a list of CCDs from exposure references.

This essentially inverts the exposure-level references (which provides a list of CCDs for each exposure), by providing a dataId list for each CCD. Consider an input list of exposures [e1, e2, e3], and each exposure has CCDs c1 and c2. Then this function returns:

{(c1,): [e1c1, e2c1, e3c1], (c2,): [e1c2, e2c2, e3c2]}

This is a dict whose keys are tuples of the identifying values of a CCD (usually just the CCD number) and the values are lists of dataIds for that CCD in each exposure. A missing dataId is given the value None.

Parameters

expRefList	List of data references for exposures
level	Level for the butler to generate CCDs
ccdKeys	DataId keywords that identify a CCD

Returns

dict of data identifier lists for each CCD; keys are values of ccdKeys in order

Definition at line 203 of file constructCalibs.py.

def getCcdIdListFromExposures(expRefList, level="sensor", ccdKeys=["ccd"]):
    """!Determine a list of CCDs from exposure references

    This essentially inverts the exposure-level references (which
    provides a list of CCDs for each exposure), by providing
    a dataId list for each CCD.  Consider an input list of exposures
    [e1, e2, e3], and each exposure has CCDs c1 and c2.  Then this
    function returns:

        {(c1,): [e1c1, e2c1, e3c1], (c2,): [e1c2, e2c2, e3c2]}

    This is a dict whose keys are tuples of the identifying values of a
    CCD (usually just the CCD number) and the values are lists of dataIds
    for that CCD in each exposure.  A missing dataId is given the value
    None.

    @param expRefList   List of data references for exposures
    @param level        Level for the butler to generate CCDs
    @param ccdKeys      DataId keywords that identify a CCD
    @return dict of data identifier lists for each CCD;
            keys are values of ccdKeys in order
    """
    expIdList = [[ccdRef.dataId for ccdRef in expRef.subItems(
        level)] for expRef in expRefList]

    # Determine what additional keys make a CCD from an exposure
    if len(ccdKeys) != len(set(ccdKeys)):
        raise RuntimeError("Duplicate keys found in ccdKeys: %s" % ccdKeys)
    ccdNames = set()  # Set of tuples which are values for each of the CCDs in an exposure
    for ccdIdList in expIdList:
        for ccdId in ccdIdList:
            name = dictToTuple(ccdId, ccdKeys)
            ccdNames.add(name)

    # Turn the list of CCDs for each exposure into a list of exposures for
    # each CCD
    ccdLists = {}
    for n, ccdIdList in enumerate(expIdList):
        for ccdId in ccdIdList:
            name = dictToTuple(ccdId, ccdKeys)
            if name not in ccdLists:
                ccdLists[name] = []
            ccdLists[name].append(ccdId)

    for ccd in ccdLists:
        # Sort the list by the dataId values (ordered by key)
        ccdLists[ccd] = sorted(ccdLists[ccd], key=lambda dd: dictToTuple(dd, sorted(dd.keys())))

    return ccdLists

getSize()

def lsst.pipe.drivers.constructCalibs.getSize

(

dimList

)

Determine a consistent size, given a list of image sizes

Definition at line 180 of file constructCalibs.py.

def getSize(dimList):
    """Determine a consistent size, given a list of image sizes"""
    dim = set((w, h) for w, h in dimList)
    dim.discard(None)
    if len(dim) != 1:
        raise RuntimeError("Inconsistent dimensions: %s" % dim)
    return dim.pop()

mapToMatrix()

def lsst.pipe.drivers.constructCalibs.mapToMatrix	(		pool,
			func,
			ccdIdLists,
			args,
			kwargs
	)

Generate a matrix of results using pool.map

The function should have the call signature:
    func(cache, dataId, *args, **kwargs)

We return a dict mapping 'ccd name' to a list of values for
each exposure.

@param pool  Process pool
@param func  Function to call for each dataId
@param ccdIdLists  Dict of data identifier lists for each CCD name
@return matrix of results

Definition at line 254 of file constructCalibs.py.

def mapToMatrix(pool, func, ccdIdLists, *args, **kwargs):
    """Generate a matrix of results using pool.map

    The function should have the call signature:
        func(cache, dataId, *args, **kwargs)

    We return a dict mapping 'ccd name' to a list of values for
    each exposure.

    @param pool  Process pool
    @param func  Function to call for each dataId
    @param ccdIdLists  Dict of data identifier lists for each CCD name
    @return matrix of results
    """
    dataIdList = sum(ccdIdLists.values(), [])
    resultList = pool.map(func, dataIdList, *args, **kwargs)
    # Piece everything back together
    data = dict((ccdName, [None] * len(expList)) for ccdName, expList in ccdIdLists.items())
    indices = dict(sum([[(tuple(dataId.values()) if dataId is not None else None, (ccdName, expNum))
                         for expNum, dataId in enumerate(expList)]
                        for ccdName, expList in ccdIdLists.items()], []))
    for dataId, result in zip(dataIdList, resultList):
        if dataId is None:
            continue
        ccdName, expNum = indices[tuple(dataId.values())]
        data[ccdName][expNum] = result
    return data