lsst.cp.pipe.astierCovPtcFit Namespace Reference

Classes
class	CovFit
class	Pol2d

Functions
def	computeApproximateAcoeffs (covModel, muEl, gain)
def	makeCovArray (inputTuple, maxRangeFromTuple=8)
def	symmetrize (inputArray)

Function Documentation

computeApproximateAcoeffs()

def lsst.cp.pipe.astierCovPtcFit.computeApproximateAcoeffs	(		covModel,
			muEl,
			gain
	)

Compute the "a" coefficients of the Antilogus+14 (1402.0725) model as in
Guyonnet+15 (1501.01577, eq. 16, the slope of cov/var at a given flux mu in electrons).

Eq. 16 of 1501.01577 is an approximation to the more complete model in Astier+19 (1905.08677).

Parameters
---------
covModel : `list`
    Covariance model from Eq. 20 in Astier+19.

muEl : `np.array`
    Mean signal in electrons

gain : `float`
    Gain in e-/ADU.

Returns
-------
aCoeffsOld: `numpy.array`
    Slope of cov/var at a given flux mu in electrons.

Notes
-----
Returns the "a" array, computed this way, to be compared to the actual a_array from the full model
(fit.geA()).

Definition at line 34 of file astierCovPtcFit.py.

def computeApproximateAcoeffs(covModel, muEl, gain):
    """Compute the "a" coefficients of the Antilogus+14 (1402.0725) model as in
    Guyonnet+15 (1501.01577, eq. 16, the slope of cov/var at a given flux mu in electrons).
 
    Eq. 16 of 1501.01577 is an approximation to the more complete model in Astier+19 (1905.08677).
 
    Parameters
    ---------
    covModel : `list`
        Covariance model from Eq. 20 in Astier+19.
 
    muEl : `np.array`
        Mean signal in electrons
 
    gain : `float`
        Gain in e-/ADU.
 
    Returns
    -------
    aCoeffsOld: `numpy.array`
        Slope of cov/var at a given flux mu in electrons.
 
    Notes
    -----
    Returns the "a" array, computed this way, to be compared to the actual a_array from the full model
    (fit.geA()).
    """
    covModel = np.array(covModel)
    var = covModel[0, 0, 0]  # ADU^2
    # For a result in electrons^-1, we have to use mu in electrons.
    return covModel[0, :, :]/(var*muEl)
 
 

makeCovArray()

def lsst.cp.pipe.astierCovPtcFit.makeCovArray	(		inputTuple,
			maxRangeFromTuple = 8
	)

Make covariances array from tuple.

Parameters
----------
inputTuple: `numpy.recarray`
    Recarray with rows with at least (mu, cov, var, i, j, npix), where:
    mu : 0.5*(m1 + m2), 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.

maxRangeFromTuple: `int`
    Maximum range to select from tuple.

Returns
-------
cov: `numpy.array`
    Covariance arrays, indexed by mean signal mu.

vCov: `numpy.array`
    Variance arrays, indexed by mean signal mu.

muVals: `numpy.array`
    List of mean signal values.

Notes
-----

The input tuple should contain  the following rows:
(mu, cov, var, i, j, npix), with one entry per lag, and image pair.
Different lags(i.e. different i and j) from the same
image pair have the same values of mu1 and mu2. When i==j==0, cov
= var.

If the input tuple contains several video channels, one should
select the data of a given channel *before* entering this
routine, as well as apply(e.g.) saturation cuts.

The routine returns cov[k_mu, j, i], vcov[(same indices)], and mu[k]
where the first index of cov matches the one in mu.

This routine implements the loss of variance due to
clipping cuts when measuring variances and covariance, but this should happen inside
the measurement code, where the cuts are readily available.

Definition at line 67 of file astierCovPtcFit.py.

def makeCovArray(inputTuple, maxRangeFromTuple=8):
    """Make covariances array from tuple.
 
    Parameters
    ----------
    inputTuple: `numpy.recarray`
        Recarray with rows with at least (mu, cov, var, i, j, npix), where:
        mu : 0.5*(m1 + m2), 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.
 
    maxRangeFromTuple: `int`
        Maximum range to select from tuple.
 
    Returns
    -------
    cov: `numpy.array`
        Covariance arrays, indexed by mean signal mu.
 
    vCov: `numpy.array`
        Variance arrays, indexed by mean signal mu.
 
    muVals: `numpy.array`
        List of mean signal values.
 
    Notes
    -----
 
    The input tuple should contain  the following rows:
    (mu, cov, var, i, j, npix), with one entry per lag, and image pair.
    Different lags(i.e. different i and j) from the same
    image pair have the same values of mu1 and mu2. When i==j==0, cov
    = var.
 
    If the input tuple contains several video channels, one should
    select the data of a given channel *before* entering this
    routine, as well as apply(e.g.) saturation cuts.
 
    The routine returns cov[k_mu, j, i], vcov[(same indices)], and mu[k]
    where the first index of cov matches the one in mu.
 
    This routine implements the loss of variance due to
    clipping cuts when measuring variances and covariance, but this should happen inside
    the measurement code, where the cuts are readily available.
 
    """
    if maxRangeFromTuple is not None:
        cut = (inputTuple['i'] < maxRangeFromTuple) & (inputTuple['j'] < maxRangeFromTuple)
        cutTuple = inputTuple[cut]
    else:
        cutTuple = inputTuple
    # increasing mu order, so that we can group measurements with the same mu
    muTemp = cutTuple['mu']
    ind = np.argsort(muTemp)
 
    cutTuple = cutTuple[ind]
    # should group measurements on the same image pairs(same average)
    mu = cutTuple['mu']
    xx = np.hstack(([mu[0]], mu))
    delta = xx[1:] - xx[:-1]
    steps, = np.where(delta > 0)
    ind = np.zeros_like(mu, dtype=int)
    ind[steps] = 1
    ind = np.cumsum(ind)  # this acts as an image pair index.
    # now fill the 3-d cov array(and variance)
    muVals = np.array(np.unique(mu))
    i = cutTuple['i'].astype(int)
    j = cutTuple['j'].astype(int)
    c = 0.5*cutTuple['cov']
    n = cutTuple['npix']
    v = 0.5*cutTuple['var']
    # book and fill
    cov = np.ndarray((len(muVals), np.max(i)+1, np.max(j)+1))
    var = np.zeros_like(cov)
    cov[ind, i, j] = c
    var[ind, i, j] = v**2/n
    var[:, 0, 0] *= 2  # var(v) = 2*v**2/N
    # compensate for loss of variance and covariance due to outlier elimination(sigma clipping)
    # when computing variances(cut to 4 sigma): 1 per mill for variances and twice as
    # much for covariances:
    fact = 1.0  # 1.00107
    cov *= fact*fact
    cov[:, 0, 0] /= fact
 
    return cov, var, muVals
 
 

symmetrize()

def lsst.cp.pipe.astierCovPtcFit.symmetrize

(

inputArray

)

 Copy array over 4 quadrants prior to convolution.

Parameters
----------
inputarray: `numpy.array`
    Input array to symmetrize.

Returns
-------
aSym: `numpy.array`
    Symmetrized array.

Definition at line 159 of file astierCovPtcFit.py.

def symmetrize(inputArray):
    """ Copy array over 4 quadrants prior to convolution.
 
    Parameters
    ----------
    inputarray: `numpy.array`
        Input array to symmetrize.
 
    Returns
    -------
    aSym: `numpy.array`
        Symmetrized array.
    """
 
    targetShape = list(inputArray.shape)
    r1, r2 = inputArray.shape[-1], inputArray.shape[-2]
    targetShape[-1] = 2*r1-1
    targetShape[-2] = 2*r2-1
    aSym = np.ndarray(tuple(targetShape))
    aSym[..., r2-1:, r1-1:] = inputArray
    aSym[..., r2-1:, r1-1::-1] = inputArray
    aSym[..., r2-1::-1, r1-1::-1] = inputArray
    aSym[..., r2-1::-1, r1-1:] = inputArray
 
    return aSym