lsst.cp.pipe.makeBrighterFatterKernel Namespace Reference

Classes
class	BrighterFatterGain
class	BrighterFatterKernel
class	BrighterFatterKernelTaskDataIdContainer
class	MakeBrighterFatterKernelTask
class	MakeBrighterFatterKernelTaskConfig

Functions
def	calcBiasCorr (fluxLevels, imageShape, repeats=1, seed=0, addCorrelations=False, correlationStrength=0.1, maxLag=10, nSigmaClip=5, border=10, logger=None)

Function Documentation

calcBiasCorr()

def lsst.cp.pipe.makeBrighterFatterKernel.calcBiasCorr	(		fluxLevels,
			imageShape,
			repeats = 1,
			seed = 0,
			addCorrelations = False,
			correlationStrength = 0.1,
			maxLag = 10,
			nSigmaClip = 5,
			border = 10,
			logger = None
	)

Calculate the bias induced when sigma-clipping non-Gaussian distributions.

Fill image-pairs of the specified size with Poisson-distributed values,
adding correlations as necessary. Then calculate the cross correlation,
and calculate the bias induced using the cross-correlation image
and the image means.

Parameters:
-----------
fluxLevels : `list` of `int`
    The mean flux levels at which to simulate.
    Nominal values might be something like [70000, 90000, 110000]
imageShape : `tuple` of `int`
    The shape of the image array to simulate, nx by ny pixels.
repeats : `int`, optional
    Number of repeats to perform so that results
    can be averaged to improve SNR.
seed : `int`, optional
    The random seed to use for the Poisson points.
addCorrelations : `bool`, optional
    Whether to add brighter-fatter-like correlations to the simulated images
    If true, a correlation between x_{i,j} and x_{i+1,j+1} is introduced
    by adding a*x_{i,j} to x_{i+1,j+1}
correlationStrength : `float`, optional
    The strength of the correlations.
    This is the value of the coefficient `a` in the above definition.
maxLag : `int`, optional
    The maximum lag to work to in pixels
nSigmaClip : `float`, optional
    Number of sigma to clip to when calculating the sigma-clipped mean.
border : `int`, optional
    Number of border pixels to mask
logger : `lsst.log.Log`, optional
    Logger to use. Instantiated anew if not provided.

Returns:
--------
biases : `dict` [`float`, `list` of `float`]
    A dictionary, keyed by flux level, containing a list of the biases
    for each repeat at that flux level
means : `dict` [`float`, `list` of `float`]
    A dictionary, keyed by flux level, containing a list of the average
    mean fluxes (average of the mean of the two images)
    for the image pairs at that flux level
xcorrs : `dict` [`float`, `list` of `np.ndarray`]
    A dictionary, keyed by flux level, containing a list of the xcorr
    images for the image pairs at that flux level

Definition at line 1609 of file makeBrighterFatterKernel.py.

def calcBiasCorr(fluxLevels, imageShape, repeats=1, seed=0, addCorrelations=False,
                 correlationStrength=0.1, maxLag=10, nSigmaClip=5, border=10, logger=None):
    """Calculate the bias induced when sigma-clipping non-Gaussian distributions.
 
    Fill image-pairs of the specified size with Poisson-distributed values,
    adding correlations as necessary. Then calculate the cross correlation,
    and calculate the bias induced using the cross-correlation image
    and the image means.
 
    Parameters:
    -----------
    fluxLevels : `list` of `int`
        The mean flux levels at which to simulate.
        Nominal values might be something like [70000, 90000, 110000]
    imageShape : `tuple` of `int`
        The shape of the image array to simulate, nx by ny pixels.
    repeats : `int`, optional
        Number of repeats to perform so that results
        can be averaged to improve SNR.
    seed : `int`, optional
        The random seed to use for the Poisson points.
    addCorrelations : `bool`, optional
        Whether to add brighter-fatter-like correlations to the simulated images
        If true, a correlation between x_{i,j} and x_{i+1,j+1} is introduced
        by adding a*x_{i,j} to x_{i+1,j+1}
    correlationStrength : `float`, optional
        The strength of the correlations.
        This is the value of the coefficient `a` in the above definition.
    maxLag : `int`, optional
        The maximum lag to work to in pixels
    nSigmaClip : `float`, optional
        Number of sigma to clip to when calculating the sigma-clipped mean.
    border : `int`, optional
        Number of border pixels to mask
    logger : `lsst.log.Log`, optional
        Logger to use. Instantiated anew if not provided.
 
    Returns:
    --------
    biases : `dict` [`float`, `list` of `float`]
        A dictionary, keyed by flux level, containing a list of the biases
        for each repeat at that flux level
    means : `dict` [`float`, `list` of `float`]
        A dictionary, keyed by flux level, containing a list of the average
        mean fluxes (average of the mean of the two images)
        for the image pairs at that flux level
    xcorrs : `dict` [`float`, `list` of `np.ndarray`]
        A dictionary, keyed by flux level, containing a list of the xcorr
        images for the image pairs at that flux level
    """
    if logger is None:
        logger = lsstLog.Log.getDefaultLogger()
 
    means = {f: [] for f in fluxLevels}
    xcorrs = {f: [] for f in fluxLevels}
    biases = {f: [] for f in fluxLevels}
 
    config = MakeBrighterFatterKernelTaskConfig()
    config.isrMandatorySteps = []  # no isr but the validation routine is still run
    config.isrForbiddenSteps = []
    config.nSigmaClipXCorr = nSigmaClip
    config.nPixBorderXCorr = border
    config.maxLag = maxLag
    task = MakeBrighterFatterKernelTask(config=config)
 
    im0 = afwImage.maskedImage.MaskedImageF(imageShape[1], imageShape[0])
    im1 = afwImage.maskedImage.MaskedImageF(imageShape[1], imageShape[0])
 
    random = np.random.RandomState(seed)
 
    for rep in range(repeats):
        for flux in fluxLevels:
            data0 = random.poisson(flux, (imageShape)).astype(float)
            data1 = random.poisson(flux, (imageShape)).astype(float)
            if addCorrelations:
                data0[1:, 1:] += correlationStrength*data0[: -1, : -1]
                data1[1:, 1:] += correlationStrength*data1[: -1, : -1]
            im0.image.array[:, :] = data0
            im1.image.array[:, :] = data1
 
            _xcorr, _means = task._crossCorrelate(im0, im1, runningBiasCorrSim=True)
 
            means[flux].append(_means)
            xcorrs[flux].append(_xcorr)
            if addCorrelations:
                bias = xcorrs[flux][-1][1, 1]/means[flux][-1]*(1 + correlationStrength)/correlationStrength
                msg = f"Simulated/expected avg. flux: {flux:.1f}, {(means[flux][-1]/2):.1f}"
                logger.info(msg)
                logger.info(f"Bias: {bias:.6f}")
            else:
                bias = xcorrs[flux][-1][0, 0]/means[flux][-1]
                msg = f"Simulated/expected avg. flux: {flux:.1f}, {(means[flux][-1]/2):.1f}"
                logger.info(msg)
                logger.info(f"Bias: {bias:.6f}")
            biases[flux].append(bias)
 
    return biases, means, xcorrs