lsst.cp.pipe.astierCovPtcFit.CovFit Class Reference

Public Member Functions
def	__init__ (self, inputTuple, maxRangeFromTuple=8, meanSignalMask=[])
def	subtractDistantOffset (self, maxLag=8, startLag=5, polDegree=1)
def	copy (self)
def	initFit (self)
def	getParamValues (self)
def	setParamValues (self, p)
def	evalCovModel (self, mu=None)
def	getA (self)
def	getB (self)
def	getC (self)
def	getACov (self)
def	getASig (self)
def	getBCov (self)
def	getCCov (self)
def	getGainErr (self)
def	getNoiseCov (self)
def	getNoiseSig (self)
def	getGain (self)
def	getRon (self)
def	getRonErr (self)
def	getNoise (self)
def	getMaskCov (self, i, j)
def	setAandB (self, a, b)
def	chi2 (self)
def	wres (self, params=None)
def	weightedRes (self, params=None)
def	fitFullModel (self, pInit=None)
def	ndof (self)
def	getFitData (self, i, j, divideByMu=False, unitsElectrons=False, returnMasked=False)
def	__call__ (self, params)

Public Attributes
	mu
	sqrtW
	r
	logger
	maskMu
	cov
	vcov
	params
	covParams

Detailed Description

A class to fit the models in Astier+19 to flat covariances.

This code implements the model(and the fit thereof) described in
Astier+19: https://arxiv.org/pdf/1905.08677.pdf
For the time being it uses as input a numpy recarray (tuple with named tags) which
contains one row per covariance and per pair: see the routine makeCovArray.

Parameters
----------
inputTuple: `numpy.recarray`
    Tuple 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`, optional
    Maximum range to select from tuple.

meanSignalMask: `list`[`bool`], optional
    Mask of mean signal 1D array. Use all entries if empty.

Definition at line 213 of file astierCovPtcFit.py.

Constructor & Destructor Documentation

__init__()

def lsst.cp.pipe.astierCovPtcFit.CovFit.__init__	(		self,
			inputTuple,
			maxRangeFromTuple = 8,
			meanSignalMask = []
	)

Definition at line 241 of file astierCovPtcFit.py.

    def __init__(self, inputTuple, maxRangeFromTuple=8, meanSignalMask=[]):
        self.cov, self.vcov, self.mu = makeCovArray(inputTuple, maxRangeFromTuple)
        # make it nan safe, replacing nan's with 0 in weights
        self.sqrtW = np.nan_to_num(1./np.sqrt(self.vcov))
        self.r = self.cov.shape[1]
        self.logger = lsstLog.Log.getDefaultLogger()
        if len(meanSignalMask):
            self.maskMu = meanSignalMask
        else:
            self.maskMu = np.repeat(True, len(self.mu))
 

Member Function Documentation

__call__()

def lsst.cp.pipe.astierCovPtcFit.CovFit.__call__	(		self,
			params
	)

Definition at line 664 of file astierCovPtcFit.py.

    def __call__(self, params):
        self.setParamValues(params)
        chi2 = self.chi2()
 
        return chi2

chi2()

def lsst.cp.pipe.astierCovPtcFit.CovFit.chi2

(

self

)

Calculate weighted chi2 of full-model fit.

Definition at line 518 of file astierCovPtcFit.py.

    def chi2(self):
        """Calculate weighted chi2 of full-model fit."""
        return(self.weightedRes()**2).sum()
 

copy()

def lsst.cp.pipe.astierCovPtcFit.CovFit.copy

(

self

)

Make a copy of params

Definition at line 284 of file astierCovPtcFit.py.

    def copy(self):
        """Make a copy of params"""
        cop = copy.deepcopy(self)
        # deepcopy does not work for FitParameters.
        if hasattr(self, 'params'):
            cop.params = self.params.copy()
        return cop
 

evalCovModel()

def lsst.cp.pipe.astierCovPtcFit.CovFit.evalCovModel	(		self,
			mu = None
	)

Computes full covariances model (Eq. 20 of Astier+19).

Parameters
----------
mu: `numpy.array`, optional
    List of mean signals.

Returns
-------
covModel: `numpy.array`
    Covariances model.

Notes
-----
By default, computes the covModel for the mu's stored(self.mu).

Returns cov[Nmu, self.r, self.r]. The variance for the PTC is cov[:, 0, 0].
mu and cov are in ADUs and ADUs squared. To use electrons for both,
the gain should be set to 1. This routine implements the model in Astier+19 (1905.08677).

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 342 of file astierCovPtcFit.py.

    def evalCovModel(self, mu=None):
        """Computes full covariances model (Eq. 20 of Astier+19).
 
        Parameters
        ----------
        mu: `numpy.array`, optional
            List of mean signals.
 
        Returns
        -------
        covModel: `numpy.array`
            Covariances model.
 
        Notes
        -----
        By default, computes the covModel for the mu's stored(self.mu).
 
        Returns cov[Nmu, self.r, self.r]. The variance for the PTC is cov[:, 0, 0].
        mu and cov are in ADUs and ADUs squared. To use electrons for both,
        the gain should be set to 1. This routine implements the model in Astier+19 (1905.08677).
 
        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".
        """
        sa = (self.r, self.r)
        a = self.params['a'].full.reshape(sa)
        c = self.params['c'].full.reshape(sa)
        gain = self.params['gain'].full[0]
        noise = self.params['noise'].full.reshape(sa)
        # pad a with zeros and symmetrize
        aEnlarged = np.zeros((int(sa[0]*1.5)+1, int(sa[1]*1.5)+1))
        aEnlarged[0:sa[0], 0:sa[1]] = a
        aSym = symmetrize(aEnlarged)
        # pad c with zeros and symmetrize
        cEnlarged = np.zeros((int(sa[0]*1.5)+1, int(sa[1]*1.5)+1))
        cEnlarged[0:sa[0], 0:sa[1]] = c
        cSym = symmetrize(cEnlarged)
        a2 = fftconvolve(aSym, aSym, mode='same')
        a3 = fftconvolve(a2, aSym, mode='same')
        ac = fftconvolve(aSym, cSym, mode='same')
        (xc, yc) = np.unravel_index(np.abs(aSym).argmax(), a2.shape)
        range = self.r
        a1 = a[np.newaxis, :, :]
        a2 = a2[np.newaxis, xc:xc + range, yc:yc + range]
        a3 = a3[np.newaxis, xc:xc + range, yc:yc + range]
        ac = ac[np.newaxis, xc:xc + range, yc:yc + range]
        c1 = c[np.newaxis, ::]
        if mu is None:
            mu = self.mu
        # assumes that mu is 1d
        bigMu = mu[:, np.newaxis, np.newaxis]*gain
        # c(=a*b in Astier+19) also has a contribution to the last term, that is absent for now.
        covModel = (bigMu/(gain*gain)*(a1*bigMu+2./3.*(bigMu*bigMu)*(a2 + c1) +
                    (1./3.*a3 + 5./6.*ac)*(bigMu*bigMu*bigMu)) + noise[np.newaxis, :, :]/gain**2)
        # add the Poisson term, and the read out noise (variance)
        covModel[:, 0, 0] += mu/gain
 
        return covModel
 

fitFullModel()

def lsst.cp.pipe.astierCovPtcFit.CovFit.fitFullModel	(		self,
			pInit = None
	)

Fit measured covariances to full model in Astier+19 (Eq. 20)

Parameters
----------
pInit : `list`
    Initial parameters of the fit.
    len(pInit) = #entries(a) + #entries(c) + #entries(noise) + 1
    len(pInit) = r^2 + r^2 + r^2 + 1, where "r" is the maximum lag considered for the
    covariances calculation, and the extra "1" is the gain.
    If "b" is 0, then "c" is 0, and len(pInit) will have r^2 fewer entries.

Returns
-------
params : `np.array`
    Fit parameters (see "Notes" below).

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 544 of file astierCovPtcFit.py.

    def fitFullModel(self, pInit=None):
        """Fit measured covariances to full model in Astier+19 (Eq. 20)
 
        Parameters
        ----------
        pInit : `list`
            Initial parameters of the fit.
            len(pInit) = #entries(a) + #entries(c) + #entries(noise) + 1
            len(pInit) = r^2 + r^2 + r^2 + 1, where "r" is the maximum lag considered for the
            covariances calculation, and the extra "1" is the gain.
            If "b" is 0, then "c" is 0, and len(pInit) will have r^2 fewer entries.
 
        Returns
        -------
        params : `np.array`
            Fit parameters (see "Notes" below).
 
        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".
        """
 
        if pInit is None:
            pInit = self.getParamValues()
 
        params, paramsCov, _, mesg, ierr = leastsq(self.weightedRes, pInit, full_output=True)
        self.covParams = paramsCov
 
        return params
 

getA()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getA

(

self

)

'a' matrix from Astier+19(e.g., Eq. 20)

Definition at line 408 of file astierCovPtcFit.py.

    def getA(self):
        """'a' matrix from Astier+19(e.g., Eq. 20)"""
        return self.params['a'].full.reshape(self.r, self.r)
 

getACov()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getACov

(

self

)

Get covariance matrix of "a" coefficients from fit

Definition at line 431 of file astierCovPtcFit.py.

    def getACov(self):
        """Get covariance matrix of "a" coefficients from fit"""
        if self._getCovParams('a') is not None:
            cova = self._getCovParams('a').reshape((self.r, self.r, self.r, self.r))
        else:
            cova = None
        return cova
 

getASig()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getASig

(

self

)

Square root of diagonal of the parameter covariance of the fitted "a" matrix

Definition at line 439 of file astierCovPtcFit.py.

    def getASig(self):
        """Square root of diagonal of the parameter covariance of the fitted "a" matrix"""
        if self._getCovParams('a') is not None:
            sigA = np.sqrt(self._getCovParams('a').diagonal()).reshape((self.r, self.r))
        else:
            sigA = None
        return sigA
 

getB()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getB

(

self

)

'b' matrix from Astier+19(e.g., Eq. 20)

Definition at line 412 of file astierCovPtcFit.py.

    def getB(self):
        """'b' matrix from Astier+19(e.g., Eq. 20)"""
        return self.params['c'].full.reshape(self.r, self.r)/self.getA()
 

getBCov()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getBCov

(

self

)

Get covariance matrix of "a" coefficients from fit
b = c /a

Definition at line 447 of file astierCovPtcFit.py.

    def getBCov(self):
        """Get covariance matrix of "a" coefficients from fit
        b = c /a
        """
        covb = self._getCovParams('c')
        aval = self.getA().flatten()
        factor = np.outer(aval, aval)
        covb /= factor
        return covb.reshape((self.r, self.r, self.r, self.r))
 

getC()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getC

(

self

)

'c'='ab' matrix from Astier+19(e.g., Eq. 20)

Definition at line 416 of file astierCovPtcFit.py.

    def getC(self):
        """'c'='ab' matrix from Astier+19(e.g., Eq. 20)"""
        return np.array(self.params['c'].full.reshape(self.r, self.r))
 

getCCov()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getCCov

(

self

)

Get covariance matrix of "c" coefficients from fit

Definition at line 457 of file astierCovPtcFit.py.

    def getCCov(self):
        """Get covariance matrix of "c" coefficients from fit"""
        cova = self._getCovParams('c')
        return cova.reshape((self.r, self.r, self.r, self.r))
 

getFitData()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getFitData	(		self,
			i,
			j,
			divideByMu = False,
			unitsElectrons = 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.

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

unitsElectrons : `bool`, optional
    mu, covariance, and model are in ADU (or powers of ADU) If tthis parameter is true, these are
    multiplied by the adequte factors of the gain to return quantities in electrons
    (or powers of electrons).

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

Returns
-------
mu: `numpy.array`
    list of signal values (mu).

covariance: `numpy.array`
    Covariance arrays, indexed by mean signal mu (self.cov[:, i, j]).

covarianceModel: `numpy.array`
    Covariance model (model).

weights: `numpy.array`
    Weights (self.sqrtW)

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

Notes
-----
Using a CovFit object, selects from (i, j) and returns
mu*gain, self.cov[:, i, j]*gain**2 model*gain**2, and self.sqrtW/gain**2
in electrons or ADU if unitsElectrons=False.

Definition at line 594 of file astierCovPtcFit.py.

    def getFitData(self, i, j, divideByMu=False, unitsElectrons=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.
 
        divideByMu: `bool`, optional
            Divide covariance, model, and weights by signal mu?
 
        unitsElectrons : `bool`, optional
            mu, covariance, and model are in ADU (or powers of ADU) If tthis parameter is true, these are
            multiplied by the adequte factors of the gain to return quantities in electrons
            (or powers of electrons).
 
        returnMasked : `bool`, optional
            Use mask (based on weights) in returned arrays (mu, covariance, and model)?
 
        Returns
        -------
        mu: `numpy.array`
            list of signal values (mu).
 
        covariance: `numpy.array`
            Covariance arrays, indexed by mean signal mu (self.cov[:, i, j]).
 
        covarianceModel: `numpy.array`
            Covariance model (model).
 
        weights: `numpy.array`
            Weights (self.sqrtW)
 
        mask : `numpy.array`, optional
            Boolean mask of the covariance at (i,j).
 
        Notes
        -----
        Using a CovFit object, selects from (i, j) and returns
        mu*gain, self.cov[:, i, j]*gain**2 model*gain**2, and self.sqrtW/gain**2
        in electrons or ADU if unitsElectrons=False.
        """
        if unitsElectrons:
            gain = self.getGain()
        else:
            gain = 1.0
 
        mu = self.mu*gain
        covariance = self.cov[:, i, j]*(gain**2)
        covarianceModel = self.evalCovModel()[:, i, j]*(gain**2)
        weights = self.sqrtW[:, i, j]/(gain**2)
 
        # select data used for the fit:
        mask = self.getMaskCov(i, j)
        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
 

getGain()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getGain

(

self

)

Get gain (e/ADU)

Definition at line 484 of file astierCovPtcFit.py.

    def getGain(self):
        """Get gain (e/ADU)"""
        return self.params['gain'].full[0]
 

getGainErr()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getGainErr

(

self

)

Get error on fitted gain parameter

Definition at line 462 of file astierCovPtcFit.py.

    def getGainErr(self):
        """Get error on fitted gain parameter"""
        if self._getCovParams('gain') is not None:
            gainErr = np.sqrt(self._getCovParams('gain')[0][0])
        else:
            gainErr = 0.0
        return gainErr
 

getMaskCov()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getMaskCov	(		self,
			i,
			j
	)

Get mask of Cov[i,j]

Definition at line 506 of file astierCovPtcFit.py.

    def getMaskCov(self, i, j):
        """Get mask of Cov[i,j]"""
        weights = self.sqrtW[:, i, j]
        mask = weights != 0
        return mask
 

getNoise()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getNoise

(

self

)

Get noise matrix

Definition at line 502 of file astierCovPtcFit.py.

    def getNoise(self):
        """Get noise matrix"""
        return self.params['noise'].full.reshape(self.r, self.r)
 

getNoiseCov()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getNoiseCov

(

self

)

Get covariances of noise matrix from fit

Definition at line 470 of file astierCovPtcFit.py.

    def getNoiseCov(self):
        """Get covariances of noise matrix from fit"""
        covNoise = self._getCovParams('noise')
        return covNoise.reshape((self.r, self.r, self.r, self.r))
 

getNoiseSig()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getNoiseSig

(

self

)

Square root of diagonal of the parameter covariance of the fitted "noise" matrix

Definition at line 475 of file astierCovPtcFit.py.

    def getNoiseSig(self):
        """Square root of diagonal of the parameter covariance of the fitted "noise" matrix"""
        if self._getCovParams('noise') is not None:
            covNoise = self._getCovParams('noise')
            noise = np.sqrt(covNoise.diagonal()).reshape((self.r, self.r))
        else:
            noise = None
        return noise
 

getParamValues()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getParamValues

(

self

)

Return an array of free parameter values (it is a copy).

Definition at line 333 of file astierCovPtcFit.py.

    def getParamValues(self):
        """Return an array of free parameter values (it is a copy)."""
        return self.params.free + 0.
 

getRon()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getRon

(

self

)

Get readout noise (e^2)

Definition at line 488 of file astierCovPtcFit.py.

    def getRon(self):
        """Get readout noise (e^2)"""
        return self.params['noise'].full[0]
 

getRonErr()

def lsst.cp.pipe.astierCovPtcFit.CovFit.getRonErr

(

self

)

Get error on readout noise parameter

Definition at line 492 of file astierCovPtcFit.py.

    def getRonErr(self):
        """Get error on readout noise parameter"""
        ronSqrt = np.sqrt(np.fabs(self.getRon()))
        if self.getNoiseSig() is not None:
            noiseSigma = self.getNoiseSig()[0][0]
            ronErr = 0.5*(noiseSigma/np.fabs(self.getRon()))*ronSqrt
        else:
            ronErr = np.nan
        return ronErr
 

initFit()

def lsst.cp.pipe.astierCovPtcFit.CovFit.initFit

(

self

)

 Performs a crude parabolic fit of the data in order to start
the full fit close to the solution.

Definition at line 292 of file astierCovPtcFit.py.

    def initFit(self):
        """ Performs a crude parabolic fit of the data in order to start
        the full fit close to the solution.
        """
        # number of parameters for 'a' array.
        lenA = self.r*self.r
        # define parameters: c corresponds to a*b in Astier+19 (Eq. 20).
        self.params = FitParameters([('a', lenA), ('c', lenA), ('noise', lenA), ('gain', 1)])
        self.params['gain'] = 1.
        # c=0 in a first go.
        self.params['c'].fix(val=0.)
        # plumbing: extract stuff from the parameter structure
        a = self.params['a'].full.reshape(self.r, self.r)
        noise = self.params['noise'].full.reshape(self.r, self.r)
        gain = self.params['gain'].full[0]
 
        # iterate the fit to account for higher orders
        # the chi2 does not necessarily go down, so one could
        # stop when it increases
        oldChi2 = 1e30
        for _ in range(5):
            model = self.evalCovModel()  # this computes the full model.
            # loop on lags
            for i in range(self.r):
                for j in range(self.r):
                    # fit a parabola for a given lag
                    parsFit = np.polyfit(self.mu, self.cov[:, i, j] - model[:, i, j],
                                         2, w=self.sqrtW[:, i, j])
                    # model equation(Eq. 20) in Astier+19:
                    a[i, j] += parsFit[0]
                    noise[i, j] += parsFit[2]*gain*gain
                    if(i + j == 0):
                        gain = 1./(1/gain+parsFit[1])
                        self.params['gain'].full[0] = gain
            chi2 = self.chi2()
            if chi2 > oldChi2:
                break
            oldChi2 = chi2
 
        return
 

ndof()

def lsst.cp.pipe.astierCovPtcFit.CovFit.ndof

(

self

)

Number of degrees of freedom

Returns
-------
mask.sum() - len(self.params.free): `int`
    Number of usable pixels - number of parameters of fit.

Definition at line 582 of file astierCovPtcFit.py.

    def ndof(self):
        """Number of degrees of freedom
 
        Returns
        -------
        mask.sum() - len(self.params.free): `int`
            Number of usable pixels - number of parameters of fit.
        """
        mask = self.sqrtW != 0
 
        return mask.sum() - len(self.params.free)
 

setAandB()

def lsst.cp.pipe.astierCovPtcFit.CovFit.setAandB	(		self,
			a,
			b
	)

Set "a" and "b" coeffcients forfull Astier+19 model (Eq. 20). "c=a*b".

Definition at line 512 of file astierCovPtcFit.py.

    def setAandB(self, a, b):
        """Set "a" and "b" coeffcients forfull Astier+19 model (Eq. 20). "c=a*b"."""
        self.params['a'].full = a.flatten()
        self.params['c'].full = a.flatten()*b.flatten()
        return
 

setParamValues()

def lsst.cp.pipe.astierCovPtcFit.CovFit.setParamValues	(		self,
			p
	)

Set parameter values.

Definition at line 337 of file astierCovPtcFit.py.

    def setParamValues(self, p):
        """Set parameter values."""
        self.params.free = p
        return
 

subtractDistantOffset()

def lsst.cp.pipe.astierCovPtcFit.CovFit.subtractDistantOffset	(		self,
			maxLag = 8,
			startLag = 5,
			polDegree = 1
	)

Subtract a background/offset to the measured covariances.

Parameters
---------
maxLag: `int`
    Maximum lag considered

startLag: `int`
    First lag from where to start the offset subtraction.

polDegree: `int`
    Degree of 2D polynomial to fit to covariance to define offse to be subtracted.

Definition at line 252 of file astierCovPtcFit.py.

    def subtractDistantOffset(self, maxLag=8, startLag=5, polDegree=1):
        """Subtract a background/offset to the measured covariances.
 
        Parameters
        ---------
        maxLag: `int`
            Maximum lag considered
 
        startLag: `int`
            First lag from where to start the offset subtraction.
 
        polDegree: `int`
            Degree of 2D polynomial to fit to covariance to define offse to be subtracted.
        """
        assert(startLag < self.r)
        for k in range(len(self.mu)):
            # Make a copy because it is going to be altered
            w = self.sqrtW[k, ...] + 0.
            sh = w.shape
            i, j = np.meshgrid(range(sh[0]), range(sh[1]), indexing='ij')
            # kill the core for the fit
            w[:startLag, :startLag] = 0
            poly = Pol2d(i, j, self.cov[k, ...], polDegree+1, w=w)
            back = poly.eval(i, j)
            self.cov[k, ...] -= back
        self.r = maxLag
        self.cov = self.cov[:, :maxLag, :maxLag]
        self.vcov = self.vcov[:, :maxLag, :maxLag]
        self.sqrtW = self.sqrtW[:, :maxLag, :maxLag]
 
        return
 

weightedRes()

def lsst.cp.pipe.astierCovPtcFit.CovFit.weightedRes	(		self,
			params = None
	)

Weighted residuas.

Notes
-----
To be used via:
c = CovFit(nt)
c.initFit()
coeffs, cov, _, mesg, ierr = leastsq(c.weightedRes, c.getParamValues(), full_output=True)

Definition at line 532 of file astierCovPtcFit.py.

    def weightedRes(self, params=None):
        """Weighted residuas.
 
        Notes
        -----
        To be used via:
        c = CovFit(nt)
        c.initFit()
        coeffs, cov, _, mesg, ierr = leastsq(c.weightedRes, c.getParamValues(), full_output=True)
        """
        return self.wres(params).flatten()
 

wres()

def lsst.cp.pipe.astierCovPtcFit.CovFit.wres	(		self,
			params = None
	)

To be used in weightedRes

Definition at line 522 of file astierCovPtcFit.py.

    def wres(self, params=None):
        """To be used in weightedRes"""
        if params is not None:
            self.setParamValues(params)
        covModel = self.evalCovModel()
        weightedRes = (covModel-self.cov)*self.sqrtW
        maskedWeightedRes = weightedRes[self.maskMu]
 
        return maskedWeightedRes
 

Member Data Documentation

cov

lsst.cp.pipe.astierCovPtcFit.CovFit.cov

Definition at line 278 of file astierCovPtcFit.py.

covParams

lsst.cp.pipe.astierCovPtcFit.CovFit.covParams

Definition at line 578 of file astierCovPtcFit.py.

logger

lsst.cp.pipe.astierCovPtcFit.CovFit.logger

Definition at line 246 of file astierCovPtcFit.py.

maskMu

lsst.cp.pipe.astierCovPtcFit.CovFit.maskMu

Definition at line 248 of file astierCovPtcFit.py.

mu

lsst.cp.pipe.astierCovPtcFit.CovFit.mu

Definition at line 242 of file astierCovPtcFit.py.

params

lsst.cp.pipe.astierCovPtcFit.CovFit.params

Definition at line 299 of file astierCovPtcFit.py.

r

lsst.cp.pipe.astierCovPtcFit.CovFit.r

Definition at line 245 of file astierCovPtcFit.py.

sqrtW

lsst.cp.pipe.astierCovPtcFit.CovFit.sqrtW

Definition at line 244 of file astierCovPtcFit.py.

vcov

lsst.cp.pipe.astierCovPtcFit.CovFit.vcov

Definition at line 279 of file astierCovPtcFit.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/0.1.5/Linux64/cp_pipe/21.0.0-5-gb7080ec+8658c79ec4/python/lsst/cp/pipe/astierCovPtcFit.py