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.

@param dict_  dict to parse
@param keys  keys to extract (order is important)
@return tuple of values

Definition at line 185 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.

@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

Definition at line 199 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 176 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 250 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