lsst.cp.pipe.astierCovPtcUtils Namespace Reference

Classes
class	CovFft
class	LoadParams

Functions
def	fftSize (s)
def	computeCovDirect (diffImage, weightImage, maxRange)
def	covDirectValue (diffImage, weightImage, dx, dy)
def	loadData (tupleName, params)
def	fitData (tupleName, r=8, nSigmaFullFit=5.5, maxIterFullFit=3)
def	getFitDataFromCovariances (i, j, mu, fullCov, fullCovModel, fullCovSqrtWeights, gain=1.0, divideByMu=False, returnMasked=False)

Function Documentation

computeCovDirect()

def lsst.cp.pipe.astierCovPtcUtils.computeCovDirect	(		diffImage,
			weightImage,
			maxRange
	)

Compute covariances of diffImage in real space.

For lags larger than ~25, it is slower than the FFT way.
Taken from https://github.com/PierreAstier/bfptc/

Parameters
----------
diffImage : `numpy.array`
    Image to compute the covariance of.

weightImage : `numpy.array`
    Weight image of diffImage (1's and 0's for good and bad pixels, respectively).

maxRange : `int`
    Last index of the covariance to be computed.

Returns
-------
outList : `list`
    List with tuples of the form (dx, dy, var, cov, npix), where:
    dx : `int`
        Lag in x
    dy : `int`
        Lag in y
    var : `float`
        Variance at (dx, dy).
    cov : `float`
        Covariance at (dx, dy).
    nPix : `int`
        Number of pixel pairs used to evaluate var and cov.

Definition at line 128 of file astierCovPtcUtils.py.

def computeCovDirect(diffImage, weightImage, maxRange):
    """Compute covariances of diffImage in real space.
 
    For lags larger than ~25, it is slower than the FFT way.
    Taken from https://github.com/PierreAstier/bfptc/
 
    Parameters
    ----------
    diffImage : `numpy.array`
        Image to compute the covariance of.
 
    weightImage : `numpy.array`
        Weight image of diffImage (1's and 0's for good and bad pixels, respectively).
 
    maxRange : `int`
        Last index of the covariance to be computed.
 
    Returns
    -------
    outList : `list`
        List with tuples of the form (dx, dy, var, cov, npix), where:
        dx : `int`
            Lag in x
        dy : `int`
            Lag in y
        var : `float`
            Variance at (dx, dy).
        cov : `float`
            Covariance at (dx, dy).
        nPix : `int`
            Number of pixel pairs used to evaluate var and cov.
    """
    outList = []
    var = 0
    # (dy,dx) = (0,0) has to be first
    for dy in range(maxRange + 1):
        for dx in range(0, maxRange + 1):
            if (dx*dy > 0):
                cov1, nPix1 = covDirectValue(diffImage, weightImage, dx, dy)
                cov2, nPix2 = covDirectValue(diffImage, weightImage, dx, -dy)
                cov = 0.5*(cov1 + cov2)
                nPix = nPix1 + nPix2
            else:
                cov, nPix = covDirectValue(diffImage, weightImage, dx, dy)
            if (dx == 0 and dy == 0):
                var = cov
            outList.append((dx, dy, var, cov, nPix))
 
    return outList
 
 

covDirectValue()

def lsst.cp.pipe.astierCovPtcUtils.covDirectValue	(		diffImage,
			weightImage,
			dx,
			dy
	)

Compute covariances of diffImage in real space at lag (dx, dy).

Taken from https://github.com/PierreAstier/bfptc/ (c.f., appendix of Astier+19).

Parameters
----------
diffImage : `numpy.array`
    Image to compute the covariance of.

weightImage : `numpy.array`
    Weight image of diffImage (1's and 0's for good and bad pixels, respectively).

dx : `int`
    Lag in x.

dy : `int`
    Lag in y.

Returns
-------
cov : `float`
    Covariance at (dx, dy)

nPix : `int`
    Number of pixel pairs used to evaluate var and cov.

Definition at line 179 of file astierCovPtcUtils.py.

def covDirectValue(diffImage, weightImage, dx, dy):
    """Compute covariances of diffImage in real space at lag (dx, dy).
 
    Taken from https://github.com/PierreAstier/bfptc/ (c.f., appendix of Astier+19).
 
    Parameters
    ----------
    diffImage : `numpy.array`
        Image to compute the covariance of.
 
    weightImage : `numpy.array`
        Weight image of diffImage (1's and 0's for good and bad pixels, respectively).
 
    dx : `int`
        Lag in x.
 
    dy : `int`
        Lag in y.
 
    Returns
    -------
    cov : `float`
        Covariance at (dx, dy)
 
    nPix : `int`
        Number of pixel pairs used to evaluate var and cov.
    """
    (nCols, nRows) = diffImage.shape
    # switching both signs does not change anything:
    # it just swaps im1 and im2 below
    if (dx < 0):
        (dx, dy) = (-dx, -dy)
    # now, we have dx >0. We have to distinguish two cases
    # depending on the sign of dy
    if dy >= 0:
        im1 = diffImage[dy:, dx:]
        w1 = weightImage[dy:, dx:]
        im2 = diffImage[:nCols - dy, :nRows - dx]
        w2 = weightImage[:nCols - dy, :nRows - dx]
    else:
        im1 = diffImage[:nCols + dy, dx:]
        w1 = weightImage[:nCols + dy, dx:]
        im2 = diffImage[-dy:, :nRows - dx]
        w2 = weightImage[-dy:, :nRows - dx]
    # use the same mask for all 3 calculations
    wAll = w1*w2
    # do not use mean() because weightImage=0 pixels would then count
    nPix = wAll.sum()
    im1TimesW = im1*wAll
    s1 = im1TimesW.sum()/nPix
    s2 = (im2*wAll).sum()/nPix
    p = (im1TimesW*im2).sum()/nPix
    cov = p - s1*s2
 
    return cov, nPix
 
 

fftSize()

def lsst.cp.pipe.astierCovPtcUtils.fftSize

(

s

)

Calculate the size fof one dimension for the FFT

Definition at line 122 of file astierCovPtcUtils.py.

def fftSize(s):
    """Calculate the size fof one dimension for the FFT"""
    x = int(np.log(s)/np.log(2.))
    return int(2**(x+1))
 
 

fitData()

def lsst.cp.pipe.astierCovPtcUtils.fitData	(		tupleName,
			r = 8,
			nSigmaFullFit = 5.5,
			maxIterFullFit = 3
	)

Fit data to models in Astier+19.

Parameters
----------
tupleName: `numpy.recarray`
    Recarray with rows with at least ( mu1, mu2, cov ,var, i, j, npix), where:
        mu1: mean value of flat1
        mu2: mean value of flat2
        cov: covariance value at lag (i, j)
        var: variance (covariance value at lag (0, 0))
        i: lag dimension
        j: lag dimension
        npix: number of pixels used for covariance calculation.

r: `int`, optional
    Maximum lag considered (e.g., to eliminate data beyond a separation "r": ignored in the fit).

nSigmaFullFit : `float`, optional
    Sigma cut to get rid of outliers in full model fit.

maxIterFullFit : `int`, optional
    Number of iterations for full model fit.

Returns
-------
covFitList: `dict`
    Dictionary of CovFit objects, with amp names as keys.

covFitNoBList: `dict`
   Dictionary of CovFit objects, with amp names as keys (b=0 in Eq. 20 of Astier+19).

Notes
-----
The parameters of the full model for C_ij(mu) ("C_ij" and "mu" in ADU^2 and ADU, respectively)
in Astier+19 (Eq. 20) are:

    "a" coefficients (r by r matrix), units: 1/e
    "b" coefficients (r by r matrix), units: 1/e
    noise matrix (r by r matrix), units: e^2
    gain, units: e/ADU

"b" appears in Eq. 20 only through the "ab" combination, which is defined in this code as "c=ab".

Definition at line 306 of file astierCovPtcUtils.py.

def fitData(tupleName, r=8, nSigmaFullFit=5.5, maxIterFullFit=3):
    """Fit data to models in Astier+19.
 
    Parameters
    ----------
    tupleName: `numpy.recarray`
        Recarray with rows with at least ( mu1, mu2, cov ,var, i, j, npix), where:
            mu1: mean value of flat1
            mu2: mean value of flat2
            cov: covariance value at lag (i, j)
            var: variance (covariance value at lag (0, 0))
            i: lag dimension
            j: lag dimension
            npix: number of pixels used for covariance calculation.
 
    r: `int`, optional
        Maximum lag considered (e.g., to eliminate data beyond a separation "r": ignored in the fit).
 
    nSigmaFullFit : `float`, optional
        Sigma cut to get rid of outliers in full model fit.
 
    maxIterFullFit : `int`, optional
        Number of iterations for full model fit.
 
    Returns
    -------
    covFitList: `dict`
        Dictionary of CovFit objects, with amp names as keys.
 
    covFitNoBList: `dict`
       Dictionary of CovFit objects, with amp names as keys (b=0 in Eq. 20 of Astier+19).
 
    Notes
    -----
    The parameters of the full model for C_ij(mu) ("C_ij" and "mu" in ADU^2 and ADU, respectively)
    in Astier+19 (Eq. 20) are:
 
        "a" coefficients (r by r matrix), units: 1/e
        "b" coefficients (r by r matrix), units: 1/e
        noise matrix (r by r matrix), units: e^2
        gain, units: e/ADU
 
    "b" appears in Eq. 20 only through the "ab" combination, which is defined in this code as "c=ab".
    """
 
    lparams = LoadParams()
    lparams.subtractDistantValue = False
    lparams.r = r
    covFitList = loadData(tupleName, lparams)
    covFitNoBList = {}  # [None]*(exts[-1]+1)
    for ext, c in covFitList.items():
        c.fitFullModel(nSigma=nSigmaFullFit, maxFitIter=maxIterFullFit)
        covFitNoBList[ext] = c.copy()
        c.params['c'].release()
        c.fitFullModel(nSigma=nSigmaFullFit, maxFitIter=maxIterFullFit)
    return covFitList, covFitNoBList
 
 

getFitDataFromCovariances()

def lsst.cp.pipe.astierCovPtcUtils.getFitDataFromCovariances	(		i,
			j,
			mu,
			fullCov,
			fullCovModel,
			fullCovSqrtWeights,
			gain = 1.0,
			divideByMu = False,
			returnMasked = False
	)

Get measured signal and covariance, cov model, weigths, and mask at covariance lag (i, j).

Parameters
----------
i :  `int`
    Lag for covariance matrix.

j: `int`
    Lag for covariance matrix.

mu : `list`
    Mean signal values.

fullCov: `list` of `numpy.array`
    Measured covariance matrices at each mean signal level in mu.

fullCovSqrtWeights: `list` of `numpy.array`
    List of square root of measured covariances at each mean signal level in mu.

fullCovModel : `list` of `numpy.array`
    List of modeled covariances at each mean signal level in mu.

gain : `float`, optional
    Gain, in e-/ADU. If other than 1.0 (default), the returned quantities will be in
    electrons or powers of electrons.

divideByMu: `bool`, optional
    Divide returned covariance, model, and weights by the mean signal mu?

returnMasked : `bool`, optional
    Use mask (based on weights) in returned arrays (mu, covariance, and model)?

Returns
-------
mu : `numpy.array`
    list of signal values at (i, j).

covariance : `numpy.array`
    Covariance at (i, j) at each mean signal mu value (fullCov[:, i, j]).

covarianceModel : `numpy.array`
    Covariance model at (i, j).

weights : `numpy.array`
    Weights at (i, j).

mask : `numpy.array`, optional
    Boolean mask of the covariance at (i,j).

Notes
-----
This function is a method of the `CovFit` class.

Definition at line 364 of file astierCovPtcUtils.py.

def getFitDataFromCovariances(i, j, mu, fullCov, fullCovModel, fullCovSqrtWeights, gain=1.0,
                              divideByMu=False, returnMasked=False):
    """Get measured signal and covariance, cov model, weigths, and mask at covariance lag (i, j).
 
    Parameters
    ----------
    i :  `int`
        Lag for covariance matrix.
 
    j: `int`
        Lag for covariance matrix.
 
    mu : `list`
        Mean signal values.
 
    fullCov: `list` of `numpy.array`
        Measured covariance matrices at each mean signal level in mu.
 
    fullCovSqrtWeights: `list` of `numpy.array`
        List of square root of measured covariances at each mean signal level in mu.
 
    fullCovModel : `list` of `numpy.array`
        List of modeled covariances at each mean signal level in mu.
 
    gain : `float`, optional
        Gain, in e-/ADU. If other than 1.0 (default), the returned quantities will be in
        electrons or powers of electrons.
 
    divideByMu: `bool`, optional
        Divide returned covariance, model, and weights by the mean signal mu?
 
    returnMasked : `bool`, optional
        Use mask (based on weights) in returned arrays (mu, covariance, and model)?
 
    Returns
    -------
    mu : `numpy.array`
        list of signal values at (i, j).
 
    covariance : `numpy.array`
        Covariance at (i, j) at each mean signal mu value (fullCov[:, i, j]).
 
    covarianceModel : `numpy.array`
        Covariance model at (i, j).
 
    weights : `numpy.array`
        Weights at (i, j).
 
    mask : `numpy.array`, optional
        Boolean mask of the covariance at (i,j).
 
    Notes
    -----
    This function is a method of the `CovFit` class.
    """
    mu = np.array(mu)
    fullCov = np.array(fullCov)
    fullCovModel = np.array(fullCovModel)
    fullCovSqrtWeights = np.array(fullCovSqrtWeights)
    covariance = fullCov[:, i, j]*(gain**2)
    covarianceModel = fullCovModel[:, i, j]*(gain**2)
    weights = fullCovSqrtWeights[:, i, j]/(gain**2)
 
    # select data used for the fit
    mask = weights != 0
    if returnMasked:
        weights = weights[mask]
        covarianceModel = covarianceModel[mask]
        mu = mu[mask]
        covariance = covariance[mask]
 
    if divideByMu:
        covariance /= mu
        covarianceModel /= mu
        weights *= mu
    return mu, covariance, covarianceModel, weights, mask

loadData()

def lsst.cp.pipe.astierCovPtcUtils.loadData	(		tupleName,
			params
	)

Returns a list of CovFit objects, indexed by amp number.

Params
------
tupleName: `numpy.recarray`
    Recarray with rows with at least ( mu1, mu2, cov ,var, i, j, npix), where:
        mu1: mean value of flat1
        mu2: mean value of flat2
        cov: covariance value at lag (i, j)
        var: variance (covariance value at lag (0, 0))
        i: lag dimension
        j: lag dimension
        npix: number of pixels used for covariance calculation.

params: `covAstierptcUtil.LoadParams`
    Object with values to drive the bahaviour of fits.

Returns
-------
covFitList: `dict`
    Dictionary with amps as keys, and CovFit objects as values.

Definition at line 265 of file astierCovPtcUtils.py.

def loadData(tupleName, params):
    """ Returns a list of CovFit objects, indexed by amp number.
 
    Params
    ------
    tupleName: `numpy.recarray`
        Recarray with rows with at least ( mu1, mu2, cov ,var, i, j, npix), where:
            mu1: mean value of flat1
            mu2: mean value of flat2
            cov: covariance value at lag (i, j)
            var: variance (covariance value at lag (0, 0))
            i: lag dimension
            j: lag dimension
            npix: number of pixels used for covariance calculation.
 
    params: `covAstierptcUtil.LoadParams`
        Object with values to drive the bahaviour of fits.
 
    Returns
    -------
    covFitList: `dict`
        Dictionary with amps as keys, and CovFit objects as values.
    """
 
    exts = np.array(np.unique(tupleName['ampName']), dtype=str)
    covFitList = {}
    for ext in exts:
        ntext = tupleName[tupleName['ampName'] == ext]
        if params.subtractDistantValue:
            c = CovFit(ntext, params.r)
            c.subtractDistantOffset(params.r, params.start, params.offsetDegree)
        else:
            c = CovFit(ntext, params.r)
 
        cc = c.copy()
        cc.initFit()  # allows to get a crude gain.
        covFitList[ext] = cc
 
    return covFitList