lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask Class Reference

Inheritance diagram for lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask:

Public Member Functions
def	__init__ (self, *args, **kwargs)
def	runDataRef (self, dataRef)
def	run (self, filenameFull, datasetPtc, linearizer=None, log=None)
def	covAstierMakeAllPlots (self, dataset, pdfPages, log=None)
def	plotNormalizedCovariances (self, i, j, inputMu, covs, covsModel, covsWeights, covsNoB, covsModelNoB, covsWeightsNoB, expIdMask, pdfPages, offset=0.004, numberOfBins=10, plotData=True, topPlot=False, log=None)

Static Public Member Functions
def	plotCovariances (mu, covs, covsModel, covsWeights, covsNoB, covsModelNoB, covsWeightsNoB, gainDict, noiseDict, aDict, bDict, expIdMask, pdfPages)
def	plot_a_b (aDict, bDict, pdfPages, bRange=3)
def	ab_vs_dist (aDict, bDict, pdfPages, bRange=4)
def	plotAcoeffsSum (aDict, bDict, pdfPages)
def	plotRelativeBiasACoeffs (aDict, aDictNoB, fullCovsModel, fullCovsModelNoB, signalElectrons, gainDict, pdfPages, maxr=None)
def	findGroups (x, maxDiff)
def	indexForBins (x, nBins)
def	binData (x, y, binIndex, wy=None)

Static Public Attributes
	ConfigClass = PlotPhotonTransferCurveTaskConfig

Detailed Description

A class to plot the dataset from MeasurePhotonTransferCurveTask.

Parameters
----------

*args: `list`
    Positional arguments passed to the Task constructor. None used at this
    time.
**kwargs: `dict`
    Keyword arguments passed on to the Task constructor. None used at this
    time.

Definition at line 77 of file plotPtc.py.

Constructor & Destructor Documentation

__init__()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 95 of file plotPtc.py.

    def __init__(self, *args, **kwargs):
        pipeBase.CmdLineTask.__init__(self, *args, **kwargs)
        plt.interactive(False)  # stop windows popping up when plotting. When headless, use 'agg' backend too
        self.config.validate()
        self.config.freeze()
 

Member Function Documentation

ab_vs_dist()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.ab_vs_dist (   aDict,   bDict,   pdfPages,   bRange = 4  )

static

Fig. 13 of Astier+19.

Values of a and b arrays fits, averaged over amplifiers, as a function of distance.

Parameters
----------
aDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

bDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

bRange : `int`
    Maximum lag for b arrays.

Definition at line 655 of file plotPtc.py.

    def ab_vs_dist(aDict, bDict, pdfPages, bRange=4):
        """Fig. 13 of Astier+19.
 
        Values of a and b arrays fits, averaged over amplifiers, as a function of distance.
 
        Parameters
        ----------
        aDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        bDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
 
        bRange : `int`
            Maximum lag for b arrays.
        """
        assert (len(aDict) == len(bDict))
        a = []
        for amp in aDict:
            if np.isnan(aDict[amp]).all():
                continue
            a.append(aDict[amp])
        a = np.array(a)
        y = a.mean(axis=0)
        sy = a.std(axis=0)/np.sqrt(len(aDict))
        i, j = np.indices(y.shape)
        upper = (i >= j).ravel()
        r = np.sqrt(i**2 + j**2).ravel()
        y = y.ravel()
        sy = sy.ravel()
        fig = plt.figure(figsize=(6, 9))
        ax = fig.add_subplot(211)
        ax.set_xlim([0.5, r.max()+1])
        ax.errorbar(r[upper], y[upper], yerr=sy[upper], marker='o', linestyle='none', color='b',
                    label='$i>=j$')
        ax.errorbar(r[~upper], y[~upper], yerr=sy[~upper], marker='o', linestyle='none', color='r',
                    label='$i<j$')
        ax.legend(loc='upper center', fontsize='x-large')
        ax.set_xlabel(r'$\sqrt{i^2+j^2}$', fontsize='x-large')
        ax.set_ylabel(r'$a_{ij}$', fontsize='x-large')
        ax.set_yscale('log')
        ax.tick_params(axis='both', labelsize='x-large')
 
        #
        axb = fig.add_subplot(212)
        b = []
        for amp in bDict:
            if np.isnan(bDict[amp]).all():
                continue
            b.append(bDict[amp])
        b = np.array(b)
        yb = b.mean(axis=0)
        syb = b.std(axis=0)/np.sqrt(len(bDict))
        ib, jb = np.indices(yb.shape)
        upper = (ib > jb).ravel()
        rb = np.sqrt(i**2 + j**2).ravel()
        yb = yb.ravel()
        syb = syb.ravel()
        xmin = -0.2
        xmax = bRange
        axb.set_xlim([xmin, xmax+0.2])
        cutu = (r > xmin) & (r < xmax) & (upper)
        cutl = (r > xmin) & (r < xmax) & (~upper)
        axb.errorbar(rb[cutu], yb[cutu], yerr=syb[cutu], marker='o', linestyle='none', color='b',
                     label='$i>=j$')
        axb.errorbar(rb[cutl], yb[cutl], yerr=syb[cutl], marker='o', linestyle='none', color='r',
                     label='$i<j$')
        plt.legend(loc='upper center', fontsize='x-large')
        axb.set_xlabel(r'$\sqrt{i^2+j^2}$', fontsize='x-large')
        axb.set_ylabel(r'$b_{ij}$', fontsize='x-large')
        axb.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
        axb.tick_params(axis='both', labelsize='x-large')
        plt.tight_layout()
        pdfPages.savefig(fig)
 
        return
 

binData()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.binData (   x,   y,   binIndex,   wy = None  )

static

Bin data (usually for display purposes).

Patrameters
-----------
x: `numpy.array`
    Data to bin.

y: `numpy.array`
    Data to bin.

binIdex: `list`
    Bin number of each datum.

wy: `numpy.array`
    Inverse rms of each datum to use when averaging (the actual weight is wy**2).

Returns:
-------

xbin: `numpy.array`
    Binned data in x.

ybin: `numpy.array`
    Binned data in y.

wybin: `numpy.array`
    Binned weights in y, computed from wy's in each bin.

sybin: `numpy.array`
    Uncertainty on the bin average, considering actual scatter, and ignoring weights.

Definition at line 1156 of file plotPtc.py.

    def binData(x, y, binIndex, wy=None):
        """Bin data (usually for display purposes).
 
        Patrameters
        -----------
        x: `numpy.array`
            Data to bin.
 
        y: `numpy.array`
            Data to bin.
 
        binIdex: `list`
            Bin number of each datum.
 
        wy: `numpy.array`
            Inverse rms of each datum to use when averaging (the actual weight is wy**2).
 
        Returns:
        -------
 
        xbin: `numpy.array`
            Binned data in x.
 
        ybin: `numpy.array`
            Binned data in y.
 
        wybin: `numpy.array`
            Binned weights in y, computed from wy's in each bin.
 
        sybin: `numpy.array`
            Uncertainty on the bin average, considering actual scatter, and ignoring weights.
        """
 
        if wy is None:
            wy = np.ones_like(x)
        binIndexSet = set(binIndex)
        w2 = wy*wy
        xw2 = x*(w2)
        xbin = np.array([xw2[binIndex == i].sum()/w2[binIndex == i].sum() for i in binIndexSet])
 
        yw2 = y*w2
        ybin = np.array([yw2[binIndex == i].sum()/w2[binIndex == i].sum() for i in binIndexSet])
 
        wybin = np.sqrt(np.array([w2[binIndex == i].sum() for i in binIndexSet]))
        sybin = np.array([y[binIndex == i].std()/np.sqrt(np.array([binIndex == i]).sum())
                         for i in binIndexSet])
 
        return xbin, ybin, wybin, sybin

covAstierMakeAllPlots()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.covAstierMakeAllPlots	(		self,
			dataset,
			pdfPages,
			log = None
	)

Make plots for MeasurePhotonTransferCurve task when doCovariancesAstier=True.

This function call other functions that mostly reproduce the plots in Astier+19.
Most of the code is ported from Pierre Astier's repository https://github.com/PierreAstier/bfptc

Parameters
----------
dataset : `lsst.ip.isr.ptcDataset.PhotonTransferCurveDataset`
    The dataset containing the necessary information to produce the plots.

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

log : `lsst.log.Log`, optional
    Logger to handle messages

Definition at line 155 of file plotPtc.py.

    def covAstierMakeAllPlots(self, dataset, pdfPages,
                              log=None):
        """Make plots for MeasurePhotonTransferCurve task when doCovariancesAstier=True.
 
        This function call other functions that mostly reproduce the plots in Astier+19.
        Most of the code is ported from Pierre Astier's repository https://github.com/PierreAstier/bfptc
 
        Parameters
        ----------
        dataset : `lsst.ip.isr.ptcDataset.PhotonTransferCurveDataset`
            The dataset containing the necessary information to produce the plots.
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
 
        log : `lsst.log.Log`, optional
            Logger to handle messages
        """
        mu = dataset.rawMeans
        expIdMask = dataset.expIdMask
        # dictionaries with ampNames as keys
        fullCovs = dataset.covariances
        fullCovsModel = dataset.covariancesModel
        fullCovWeights = dataset.covariancesSqrtWeights
        aDict = dataset.aMatrix
        bDict = dataset.bMatrix
        fullCovsNoB = dataset.covariancesNoB
        fullCovsModelNoB = dataset.covariancesModelNoB
        fullCovWeightsNoB = dataset.covariancesSqrtWeightsNoB
        aDictNoB = dataset.aMatrixNoB
        gainDict = dataset.gain
        noiseDict = dataset.noise
 
        self.plotCovariances(mu, fullCovs, fullCovsModel, fullCovWeights, fullCovsNoB, fullCovsModelNoB,
                             fullCovWeightsNoB, gainDict, noiseDict, aDict, bDict, expIdMask, pdfPages)
        self.plotNormalizedCovariances(0, 0, mu, fullCovs, fullCovsModel, fullCovWeights, fullCovsNoB,
                                       fullCovsModelNoB, fullCovWeightsNoB, expIdMask, pdfPages,
                                       offset=0.01, topPlot=True,
                                       numberOfBins=self.config.plotNormalizedCovariancesNumberOfBins,
                                       log=log)
        self.plotNormalizedCovariances(0, 1, mu, fullCovs, fullCovsModel, fullCovWeights, fullCovsNoB,
                                       fullCovsModelNoB, fullCovWeightsNoB, expIdMask, pdfPages,
                                       numberOfBins=self.config.plotNormalizedCovariancesNumberOfBins,
                                       log=log)
        self.plotNormalizedCovariances(1, 0, mu, fullCovs, fullCovsModel, fullCovWeights, fullCovsNoB,
                                       fullCovsModelNoB, fullCovWeightsNoB, expIdMask, pdfPages,
                                       numberOfBins=self.config.plotNormalizedCovariancesNumberOfBins,
                                       log=log)
        self.plot_a_b(aDict, bDict, pdfPages)
        self.ab_vs_dist(aDict, bDict, pdfPages, bRange=4)
        self.plotAcoeffsSum(aDict, bDict, pdfPages)
        self.plotRelativeBiasACoeffs(aDict, aDictNoB, fullCovsModel, fullCovsModelNoB,
                                     self.config.signalElectronsRelativeA, gainDict, pdfPages, maxr=4)
 
        return
 

findGroups()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.findGroups (   x,   maxDiff  )

static

Group data into bins, with at most maxDiff distance between bins.

Parameters
----------
x: `list`
    Data to bin.

maxDiff: `int`
    Maximum distance between bins.

Returns
-------
index: `list`
    Bin indices.

Definition at line 1098 of file plotPtc.py.

    def findGroups(x, maxDiff):
        """Group data into bins, with at most maxDiff distance between bins.
 
        Parameters
        ----------
        x: `list`
            Data to bin.
 
        maxDiff: `int`
            Maximum distance between bins.
 
        Returns
        -------
        index: `list`
            Bin indices.
        """
        ix = np.argsort(x)
        xsort = np.sort(x)
        index = np.zeros_like(x, dtype=np.int32)
        xc = xsort[0]
        group = 0
        ng = 1
 
        for i in range(1, len(ix)):
            xval = xsort[i]
            if (xval - xc < maxDiff):
                xc = (ng*xc + xval)/(ng+1)
                ng += 1
                index[ix[i]] = group
            else:
                group += 1
                ng = 1
                index[ix[i]] = group
                xc = xval
 
        return index
 

indexForBins()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.indexForBins (   x,   nBins  )

static

Builds an index with regular binning. The result can be fed into binData.

Parameters
----------
x: `numpy.array`
    Data to bin.
nBins: `int`
    Number of bin.

Returns
-------
np.digitize(x, bins): `numpy.array`
    Bin indices.

Definition at line 1136 of file plotPtc.py.

    def indexForBins(x, nBins):
        """Builds an index with regular binning. The result can be fed into binData.
 
        Parameters
        ----------
        x: `numpy.array`
            Data to bin.
        nBins: `int`
            Number of bin.
 
        Returns
        -------
        np.digitize(x, bins): `numpy.array`
            Bin indices.
        """
 
        bins = np.linspace(x.min(), x.max() + abs(x.max() * 1e-7), nBins + 1)
        return np.digitize(x, bins)
 

plot_a_b()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.plot_a_b (   aDict,   bDict,   pdfPages,   bRange = 3  )

static

Fig. 12 of Astier+19

Color display of a and b arrays fits, averaged over channels.

Parameters
----------
aDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

bDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

bRange : `int`
    Maximum lag for b arrays.

Definition at line 602 of file plotPtc.py.

    def plot_a_b(aDict, bDict, pdfPages, bRange=3):
        """Fig. 12 of Astier+19
 
        Color display of a and b arrays fits, averaged over channels.
 
        Parameters
        ----------
        aDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        bDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
 
        bRange : `int`
            Maximum lag for b arrays.
        """
        a, b = [], []
        for amp in aDict:
            if np.isnan(aDict[amp]).all():
                continue
            a.append(aDict[amp])
            b.append(bDict[amp])
        a = np.array(a).mean(axis=0)
        b = np.array(b).mean(axis=0)
        fig = plt.figure(figsize=(7, 11))
        ax0 = fig.add_subplot(2, 1, 1)
        im0 = ax0.imshow(np.abs(a.transpose()), origin='lower', norm=mpl.colors.LogNorm())
        ax0.tick_params(axis='both', labelsize='x-large')
        ax0.set_title(r'$|a|$', fontsize='x-large')
        ax0.xaxis.set_ticks_position('bottom')
        cb0 = plt.colorbar(im0)
        cb0.ax.tick_params(labelsize='x-large')
 
        ax1 = fig.add_subplot(2, 1, 2)
        ax1.tick_params(axis='both', labelsize='x-large')
        ax1.yaxis.set_major_locator(MaxNLocator(integer=True))
        ax1.xaxis.set_major_locator(MaxNLocator(integer=True))
        im1 = ax1.imshow(1e6*b[:bRange, :bRange].transpose(), origin='lower')
        cb1 = plt.colorbar(im1)
        cb1.ax.tick_params(labelsize='x-large')
        ax1.set_title(r'$b \times 10^6$', fontsize='x-large')
        ax1.xaxis.set_ticks_position('bottom')
        plt.tight_layout()
        pdfPages.savefig(fig)
 
        return
 

plotAcoeffsSum()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.plotAcoeffsSum (   aDict,   bDict,   pdfPages  )

static

Fig. 14. of Astier+19

Cumulative sum of a_ij as a function of maximum separation. This plot displays the average over
channels.

Parameters
----------
aDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

bDict : `dict`, [`numpy.array`]
    Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
    in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

Definition at line 738 of file plotPtc.py.

    def plotAcoeffsSum(aDict, bDict, pdfPages):
        """Fig. 14. of Astier+19
 
        Cumulative sum of a_ij as a function of maximum separation. This plot displays the average over
        channels.
 
        Parameters
        ----------
        aDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'a' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        bDict : `dict`, [`numpy.array`]
            Dictionary keyed by amp names containing the fitted 'b' coefficients from the model
            in Eq. 20 of Astier+19 (if `ptcFitType` is `FULLCOVARIANCE`).
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
        """
        assert (len(aDict) == len(bDict))
        a, b = [], []
        for amp in aDict:
            if np.isnan(aDict[amp]).all() or np.isnan(bDict[amp]).all():
                continue
            a.append(aDict[amp])
            b.append(bDict[amp])
        a = np.array(a).mean(axis=0)
        b = np.array(b).mean(axis=0)
        fig = plt.figure(figsize=(7, 6))
        w = 4*np.ones_like(a)
        w[0, 1:] = 2
        w[1:, 0] = 2
        w[0, 0] = 1
        wa = w*a
        indices = range(1, a.shape[0]+1)
        sums = [wa[0:n, 0:n].sum() for n in indices]
        ax = plt.subplot(111)
        ax.plot(indices, sums/sums[0], 'o', color='b')
        ax.set_yscale('log')
        ax.set_xlim(indices[0]-0.5, indices[-1]+0.5)
        ax.set_ylim(None, 1.2)
        ax.set_ylabel(r'$[\sum_{|i|<n\  &\  |j|<n} a_{ij}] / |a_{00}|$', fontsize='x-large')
        ax.set_xlabel('n', fontsize='x-large')
        ax.tick_params(axis='both', labelsize='x-large')
        plt.tight_layout()
        pdfPages.savefig(fig)
 
        return
 

plotCovariances()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.plotCovariances (   mu,   covs,   covsModel,   covsWeights,   covsNoB,   covsModelNoB,   covsWeightsNoB,   gainDict,   noiseDict,   aDict,   bDict,   expIdMask,   pdfPages  )

static

Plot covariances and models: Cov00, Cov10, Cov01.

Figs. 6 and 7 of Astier+19

Parameters
----------
mu : `dict`, [`str`, `list`]
    Dictionary keyed by amp name with mean signal values.

covs : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing a list of measued covariances per mean flux.

covsModel : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containinging covariances model (Eq. 20 of Astier+19) per mean flux.

covsWeights : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containinging sqrt. of covariances weights.

covsNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing a list of measued covariances per mean flux ('b'=0 in
    Astier+19).

covsModelNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of Astier+19)
    per mean flux.

covsWeightsNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing sqrt. of covariances weights ('b' = 0 in Eq. 20 of
    Astier+19).

gainDict : `dict`, [`str`, `float`]
    Dictionary keyed by amp names containing the gains in e-/ADU.

noiseDict : `dict`, [`str`, `float`]
    Dictionary keyed by amp names containing the rms redout noise in e-.

aDict : `dict`, [`str`, `numpy.array`]
    Dictionary keyed by amp names containing 'a' coefficients (Eq. 20 of Astier+19).

bDict : `dict`, [`str`, `numpy.array`]
    Dictionary keyed by amp names containing 'b' coefficients (Eq. 20 of Astier+19).

expIdMask : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing the masked exposure pairs.

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

Definition at line 212 of file plotPtc.py.

    def plotCovariances(mu, covs, covsModel, covsWeights, covsNoB, covsModelNoB, covsWeightsNoB,
                        gainDict, noiseDict, aDict, bDict, expIdMask, pdfPages):
        """Plot covariances and models: Cov00, Cov10, Cov01.
 
        Figs. 6 and 7 of Astier+19
 
        Parameters
        ----------
        mu : `dict`, [`str`, `list`]
            Dictionary keyed by amp name with mean signal values.
 
        covs : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing a list of measued covariances per mean flux.
 
        covsModel : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containinging covariances model (Eq. 20 of Astier+19) per mean flux.
 
        covsWeights : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containinging sqrt. of covariances weights.
 
        covsNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing a list of measued covariances per mean flux ('b'=0 in
            Astier+19).
 
        covsModelNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of Astier+19)
            per mean flux.
 
        covsWeightsNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing sqrt. of covariances weights ('b' = 0 in Eq. 20 of
            Astier+19).
 
        gainDict : `dict`, [`str`, `float`]
            Dictionary keyed by amp names containing the gains in e-/ADU.
 
        noiseDict : `dict`, [`str`, `float`]
            Dictionary keyed by amp names containing the rms redout noise in e-.
 
        aDict : `dict`, [`str`, `numpy.array`]
            Dictionary keyed by amp names containing 'a' coefficients (Eq. 20 of Astier+19).
 
        bDict : `dict`, [`str`, `numpy.array`]
            Dictionary keyed by amp names containing 'b' coefficients (Eq. 20 of Astier+19).
 
        expIdMask : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing the masked exposure pairs.
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
        """
 
        legendFontSize = 6.5
        labelFontSize = 7
        titleFontSize = 9
        supTitleFontSize = 18
        markerSize = 25
 
        nAmps = len(covs)
        if nAmps == 2:
            nRows, nCols = 2, 1
        nRows = np.sqrt(nAmps)
        mantissa, _ = np.modf(nRows)
        if mantissa > 0:
            nRows = int(nRows) + 1
            nCols = nRows
        else:
            nRows = int(nRows)
            nCols = nRows
 
        f, ax = plt.subplots(nrows=nRows, ncols=nCols, sharex='col', sharey='row', figsize=(13, 10))
        f2, ax2 = plt.subplots(nrows=nRows, ncols=nCols, sharex='col', sharey='row', figsize=(13, 10))
        fResCov00, axResCov00 = plt.subplots(nrows=nRows, ncols=nCols, sharex='col', sharey='row',
                                             figsize=(13, 10))
        fCov01, axCov01 = plt.subplots(nrows=nRows, ncols=nCols, sharex='col', sharey='row', figsize=(13, 10))
        fCov10, axCov10 = plt.subplots(nrows=nRows, ncols=nCols, sharex='col', sharey='row', figsize=(13, 10))
 
        assert(len(covsModel) == nAmps)
        assert(len(covsWeights) == nAmps)
 
        assert(len(covsNoB) == nAmps)
        assert(len(covsModelNoB) == nAmps)
        assert(len(covsWeightsNoB) == nAmps)
 
        for i, (amp, a, a2, aResVar, a3, a4) in enumerate(zip(covs, ax.flatten(),
                                                              ax2.flatten(), axResCov00.flatten(),
                                                              axCov01.flatten(), axCov10.flatten())):
 
            muAmp, cov, model, weight = mu[amp], covs[amp], covsModel[amp], covsWeights[amp]
            if not np.isnan(np.array(cov)).all():  # If all the entries are np.nan, this is a bad amp.
                aCoeffs, bCoeffs = np.array(aDict[amp]), np.array(bDict[amp])
                gain, noise = gainDict[amp], noiseDict[amp]
                mask = expIdMask[amp]
 
                (meanVecOriginal, varVecOriginal, varVecModelOriginal,
                    weightsOriginal, _) = getFitDataFromCovariances(0, 0, muAmp, cov, model, weight)
                meanVecFinal, varVecFinal = meanVecOriginal[mask], varVecOriginal[mask]
                varVecModelFinal = varVecModelOriginal[mask]
                meanVecOutliers = meanVecOriginal[np.invert(mask)]
                varVecOutliers = varVecOriginal[np.invert(mask)]
                varWeightsFinal = weightsOriginal[mask]
                # Get weighted reduced chi2
                chi2FullModelVar = calculateWeightedReducedChi2(varVecFinal, varVecModelFinal,
                                                                varWeightsFinal, len(meanVecFinal), 4)
 
                (meanVecOrigCov01, varVecOrigCov01, varVecModelOrigCov01,
                    _, _) = getFitDataFromCovariances(0, 0, muAmp, cov, model, weight)
                meanVecFinalCov01, varVecFinalCov01 = meanVecOrigCov01[mask], varVecOrigCov01[mask]
                varVecModelFinalCov01 = varVecModelOrigCov01[mask]
                meanVecOutliersCov01 = meanVecOrigCov01[np.invert(mask)]
                varVecOutliersCov01 = varVecOrigCov01[np.invert(mask)]
 
                (meanVecOrigCov10, varVecOrigCov10, varVecModelOrigCov10,
                    _, _) = getFitDataFromCovariances(1, 0, muAmp, cov, model, weight)
                meanVecFinalCov10, varVecFinalCov10 = meanVecOrigCov10[mask], varVecOrigCov10[mask]
                varVecModelFinalCov10 = varVecModelOrigCov10[mask]
                meanVecOutliersCov10 = meanVecOrigCov10[np.invert(mask)]
                varVecOutliersCov10 = varVecOrigCov10[np.invert(mask)]
 
                # cuadratic fit for residuals below
                par2 = np.polyfit(meanVecFinal, varVecFinal, 2, w=varWeightsFinal)
                varModelFinalQuadratic = np.polyval(par2, meanVecFinal)
                chi2QuadModelVar = calculateWeightedReducedChi2(varVecFinal, varModelFinalQuadratic,
                                                                varWeightsFinal, len(meanVecFinal), 3)
 
                # fit with no 'b' coefficient (c = a*b in Eq. 20 of Astier+19)
                covNoB, modelNoB, weightNoB = covsNoB[amp], covsModelNoB[amp], covsWeightsNoB[amp]
                (meanVecOriginalNoB, varVecOriginalNoB, varVecModelOriginalNoB,
                 varWeightsOriginalNoB, _) = getFitDataFromCovariances(0, 0, muAmp, covNoB, modelNoB,
                                                                       weightNoB)
 
                meanVecFinalNoB, varVecFinalNoB, varVecModelFinalNoB, varWeightsFinalNoB = (
                    meanVecOriginalNoB[mask], varVecOriginalNoB[mask], varVecModelOriginalNoB[mask],
                    varWeightsOriginalNoB[mask])
 
                chi2FullModelNoBVar = calculateWeightedReducedChi2(varVecFinalNoB, varVecModelFinalNoB,
                                                                   varWeightsFinalNoB, len(meanVecFinalNoB),
                                                                   3)
                stringLegend = (f"Gain: {gain:.4} e/ADU \n" +
                                f"Noise: {noise:.4} e \n" +
                                r"$a_{00}$: %.3e 1/e"%aCoeffs[0, 0] +
                                "\n" + r"$b_{00}$: %.3e 1/e"%bCoeffs[0, 0] +
                                f"\nLast in fit: {meanVecFinal[-1]:.7} ADU ")
                minMeanVecFinal = np.nanmin(meanVecFinal)
                maxMeanVecFinal = np.nanmax(meanVecFinal)
                deltaXlim = maxMeanVecFinal - minMeanVecFinal
 
                a.set_xlabel(r'Mean signal ($\mu$, ADU)', fontsize=labelFontSize)
                a.set_ylabel(r'Variance (ADU$^2$)', fontsize=labelFontSize)
                a.tick_params(labelsize=11)
                a.set_xscale('linear', fontsize=labelFontSize)
                a.set_yscale('linear', fontsize=labelFontSize)
                a.scatter(meanVecFinal, varVecFinal, c='blue', marker='o', s=markerSize)
                a.scatter(meanVecOutliers, varVecOutliers, c='magenta', marker='s', s=markerSize)
                a.plot(meanVecFinal, varVecModelFinal, color='red', lineStyle='-')
                a.text(0.03, 0.7, stringLegend, transform=a.transAxes, fontsize=legendFontSize)
                a.set_title(amp, fontsize=titleFontSize)
                a.set_xlim([minMeanVecFinal - 0.2*deltaXlim, maxMeanVecFinal + 0.2*deltaXlim])
 
                # Same as above, but in log-scale
                a2.set_xlabel(r'Mean Signal ($\mu$, ADU)', fontsize=labelFontSize)
                a2.set_ylabel(r'Variance (ADU$^2$)', fontsize=labelFontSize)
                a2.tick_params(labelsize=11)
                a2.set_xscale('log')
                a2.set_yscale('log')
                a2.plot(meanVecFinal, varVecModelFinal, color='red', lineStyle='-')
                a2.scatter(meanVecFinal, varVecFinal, c='blue', marker='o', s=markerSize)
                a2.scatter(meanVecOutliers, varVecOutliers, c='magenta', marker='s', s=markerSize)
                a2.text(0.03, 0.7, stringLegend, transform=a2.transAxes, fontsize=legendFontSize)
                a2.set_title(amp, fontsize=titleFontSize)
                a2.set_xlim([minMeanVecFinal, maxMeanVecFinal])
 
                # Residuals var - model
                aResVar.set_xlabel(r'Mean signal ($\mu$, ADU)', fontsize=labelFontSize)
                aResVar.set_ylabel(r'Residuals (ADU$^2$)', fontsize=labelFontSize)
                aResVar.tick_params(labelsize=11)
                aResVar.set_xscale('linear', fontsize=labelFontSize)
                aResVar.set_yscale('linear', fontsize=labelFontSize)
                aResVar.plot(meanVecFinal, varVecFinal - varVecModelFinal, color='blue', lineStyle='-',
                             label=r'Full fit ($\chi_{\rm{red}}^2$: %g)'%chi2FullModelVar)
                aResVar.plot(meanVecFinal, varVecFinal - varModelFinalQuadratic, color='red', lineStyle='-',
                             label=r'Quadratic fit ($\chi_{\rm{red}}^2$: %g)'%chi2QuadModelVar)
                aResVar.plot(meanVecFinalNoB, varVecFinalNoB - varVecModelFinalNoB, color='green',
                             lineStyle='-',
                             label=r'Full fit (b=0) ($\chi_{\rm{red}}^2$: %g)'%chi2FullModelNoBVar)
                aResVar.axhline(color='black')
                aResVar.set_title(amp, fontsize=titleFontSize)
                aResVar.set_xlim([minMeanVecFinal - 0.2*deltaXlim, maxMeanVecFinal + 0.2*deltaXlim])
                aResVar.legend(fontsize=7)
 
                a3.set_xlabel(r'Mean signal ($\mu$, ADU)', fontsize=labelFontSize)
                a3.set_ylabel(r'Cov01 (ADU$^2$)', fontsize=labelFontSize)
                a3.tick_params(labelsize=11)
                a3.set_xscale('linear', fontsize=labelFontSize)
                a3.set_yscale('linear', fontsize=labelFontSize)
                a3.scatter(meanVecFinalCov01, varVecFinalCov01, c='blue', marker='o', s=markerSize)
                a3.scatter(meanVecOutliersCov01, varVecOutliersCov01, c='magenta', marker='s', s=markerSize)
                a3.plot(meanVecFinalCov01, varVecModelFinalCov01, color='red', lineStyle='-')
                a3.set_title(amp, fontsize=titleFontSize)
                a3.set_xlim([minMeanVecFinal - 0.2*deltaXlim, maxMeanVecFinal + 0.2*deltaXlim])
 
                a4.set_xlabel(r'Mean signal ($\mu$, ADU)', fontsize=labelFontSize)
                a4.set_ylabel(r'Cov10 (ADU$^2$)', fontsize=labelFontSize)
                a4.tick_params(labelsize=11)
                a4.set_xscale('linear', fontsize=labelFontSize)
                a4.set_yscale('linear', fontsize=labelFontSize)
                a4.scatter(meanVecFinalCov10, varVecFinalCov10, c='blue', marker='o', s=markerSize)
                a4.scatter(meanVecOutliersCov10, varVecOutliersCov10, c='magenta', marker='s', s=markerSize)
                a4.plot(meanVecFinalCov10, varVecModelFinalCov10, color='red', lineStyle='-')
                a4.set_title(amp, fontsize=titleFontSize)
                a4.set_xlim([minMeanVecFinal - 0.2*deltaXlim, maxMeanVecFinal + 0.2*deltaXlim])
 
            else:
                a.set_title(f"{amp} (BAD)", fontsize=titleFontSize)
                a2.set_title(f"{amp} (BAD)", fontsize=titleFontSize)
                a3.set_title(f"{amp} (BAD)", fontsize=titleFontSize)
                a4.set_title(f"{amp} (BAD)", fontsize=titleFontSize)
 
        f.suptitle("PTC from covariances as in Astier+19 \n Fit: Eq. 20, Astier+19",
                   fontsize=supTitleFontSize)
        pdfPages.savefig(f)
        f2.suptitle("PTC from covariances as in Astier+19 (log-log) \n Fit: Eq. 20, Astier+19",
                    fontsize=supTitleFontSize)
        pdfPages.savefig(f2)
        fResCov00.suptitle("Residuals (data-model) for Cov00 (Var)", fontsize=supTitleFontSize)
        pdfPages.savefig(fResCov00)
        fCov01.suptitle("Cov01 as in Astier+19 (nearest parallel neighbor covariance) \n" +
                        " Fit: Eq. 20, Astier+19", fontsize=supTitleFontSize)
        pdfPages.savefig(fCov01)
        fCov10.suptitle("Cov10 as in Astier+19 (nearest serial neighbor covariance) \n" +
                        "Fit: Eq. 20, Astier+19", fontsize=supTitleFontSize)
        pdfPages.savefig(fCov10)
 
        return
 

plotNormalizedCovariances()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.plotNormalizedCovariances	(		self,
			i,
			j,
			inputMu,
			covs,
			covsModel,
			covsWeights,
			covsNoB,
			covsModelNoB,
			covsWeightsNoB,
			expIdMask,
			pdfPages,
			offset = 0.004,
			numberOfBins = 10,
			plotData = True,
			topPlot = False,
			log = None
	)

Plot C_ij/mu vs mu.

Figs. 8, 10, and 11 of Astier+19

Parameters
----------
i : `int`
    Covariane lag

j : `int`
    Covariance lag

inputMu : `dict`, [`str`, `list`]
    Dictionary keyed by amp name with mean signal values.

covs : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing a list of measued covariances per mean flux.

covsModel : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containinging covariances model (Eq. 20 of Astier+19) per mean flux.

covsWeights : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containinging sqrt. of covariances weights.

covsNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing a list of measued covariances per mean flux ('b'=0 in
    Astier+19).

covsModelNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of Astier+19)
    per mean flux.

covsWeightsNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing sqrt. of covariances weights ('b' = 0 in Eq. 20 of
    Astier+19).

expIdMask : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing the masked exposure pairs.

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

offset : `float`, optional
    Constant offset factor to plot covariances in same panel (so they don't overlap).

numberOfBins : `int`, optional
    Number of bins for top and bottom plot.

plotData : `bool`, optional
    Plot the data points?

topPlot : `bool`, optional
    Plot the top plot with the covariances, and the bottom plot with the model residuals?

log : `lsst.log.Log`, optional
    Logger to handle messages.

Definition at line 446 of file plotPtc.py.

    def plotNormalizedCovariances(self, i, j, inputMu, covs, covsModel, covsWeights, covsNoB, covsModelNoB,
                                  covsWeightsNoB, expIdMask, pdfPages, offset=0.004,
                                  numberOfBins=10, plotData=True, topPlot=False, log=None):
        """Plot C_ij/mu vs mu.
 
        Figs. 8, 10, and 11 of Astier+19
 
        Parameters
        ----------
        i : `int`
            Covariane lag
 
        j : `int`
            Covariance lag
 
        inputMu : `dict`, [`str`, `list`]
            Dictionary keyed by amp name with mean signal values.
 
        covs : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing a list of measued covariances per mean flux.
 
        covsModel : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containinging covariances model (Eq. 20 of Astier+19) per mean flux.
 
        covsWeights : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containinging sqrt. of covariances weights.
 
        covsNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing a list of measued covariances per mean flux ('b'=0 in
            Astier+19).
 
        covsModelNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of Astier+19)
            per mean flux.
 
        covsWeightsNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing sqrt. of covariances weights ('b' = 0 in Eq. 20 of
            Astier+19).
 
        expIdMask : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing the masked exposure pairs.
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
 
        offset : `float`, optional
            Constant offset factor to plot covariances in same panel (so they don't overlap).
 
        numberOfBins : `int`, optional
            Number of bins for top and bottom plot.
 
        plotData : `bool`, optional
            Plot the data points?
 
        topPlot : `bool`, optional
            Plot the top plot with the covariances, and the bottom plot with the model residuals?
 
        log : `lsst.log.Log`, optional
            Logger to handle messages.
        """
        if (not topPlot):
            fig = plt.figure(figsize=(8, 10))
            gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
            gs.update(hspace=0)
            ax0 = plt.subplot(gs[0])
            plt.setp(ax0.get_xticklabels(), visible=False)
        else:
            fig = plt.figure(figsize=(8, 8))
            ax0 = plt.subplot(111)
            ax0.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
        ax0.tick_params(axis='both', labelsize='x-large')
        mue, rese, wce = [], [], []
        mueNoB, reseNoB, wceNoB = [], [], []
        for counter, amp in enumerate(covs):
            mask = expIdMask[amp]
 
            muAmp, fullCov, fullCovModel, fullCovWeight = (inputMu[amp], covs[amp], covsModel[amp],
                                                           covsWeights[amp])
            if len(fullCov) == 0:
                continue
            mu, cov, model, weightCov, _ = getFitDataFromCovariances(i, j, muAmp, fullCov, fullCovModel,
                                                                     fullCovWeight, divideByMu=True)
 
            mu, cov, model, weightCov = mu[mask], cov[mask], model[mask], weightCov[mask]
 
            mue += list(mu)
            rese += list(cov - model)
            wce += list(weightCov)
 
            fullCovNoB, fullCovModelNoB, fullCovWeightNoB = (covsNoB[amp], covsModelNoB[amp],
                                                             covsWeightsNoB[amp])
            if len(fullCovNoB) == 0:
                continue
            (muNoB, covNoB, modelNoB,
                weightCovNoB, _) = getFitDataFromCovariances(i, j, muAmp, fullCovNoB, fullCovModelNoB,
                                                             fullCovWeightNoB, divideByMu=True)
 
            muNoB, covNoB, modelNoB, weightCovNoB = (muNoB[mask], covNoB[mask], modelNoB[mask],
                                                     weightCovNoB[mask])
 
            mueNoB += list(muNoB)
            reseNoB += list(covNoB - modelNoB)
            wceNoB += list(weightCovNoB)
 
            # the corresponding fit
            fit_curve, = plt.plot(mu, model + counter*offset, '-', linewidth=4.0)
            # bin plot. len(mu) = no binning
            gind = self.indexForBins(mu, numberOfBins)
 
            xb, yb, wyb, sigyb = self.binData(mu, cov, gind, weightCov)
            plt.errorbar(xb, yb+counter*offset, yerr=sigyb, marker='o', linestyle='none', markersize=6.5,
                         color=fit_curve.get_color(), label=f"{amp} (N: {len(mu)})")
            # plot the data
            if plotData:
                points, = plt.plot(mu, cov + counter*offset, '.', color=fit_curve.get_color())
            plt.legend(loc='upper right', fontsize=8)
        # end loop on amps
        mue = np.array(mue)
        rese = np.array(rese)
        wce = np.array(wce)
        mueNoB = np.array(mueNoB)
        reseNoB = np.array(reseNoB)
        wceNoB = np.array(wceNoB)
 
        plt.xlabel(r"$\mu (el)$", fontsize='x-large')
        plt.ylabel(r"$Cov{%d%d}/\mu + Cst (el)$"%(i, j), fontsize='x-large')
        if (not topPlot):
            gind = self.indexForBins(mue, numberOfBins)
            xb, yb, wyb, sigyb = self.binData(mue, rese, gind, wce)
 
            ax1 = plt.subplot(gs[1], sharex=ax0)
            ax1.errorbar(xb, yb, yerr=sigyb, marker='o', linestyle='none', label='Full fit')
            gindNoB = self.indexForBins(mueNoB, numberOfBins)
            xb2, yb2, wyb2, sigyb2 = self.binData(mueNoB, reseNoB, gindNoB, wceNoB)
 
            ax1.errorbar(xb2, yb2, yerr=sigyb2, marker='o', linestyle='none', label='b = 0')
            ax1.tick_params(axis='both', labelsize='x-large')
            plt.legend(loc='upper left', fontsize='large')
            # horizontal line at zero
            plt.plot(xb, [0]*len(xb), '--', color='k')
            plt.ticklabel_format(style='sci', axis='x', scilimits=(0, 0))
            plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
            plt.xlabel(r'$\mu (el)$', fontsize='x-large')
            plt.ylabel(r'$Cov{%d%d}/\mu$ -model (el)'%(i, j), fontsize='x-large')
        plt.tight_layout()
        plt.suptitle(f"Nbins: {numberOfBins}")
        # overlapping y labels:
        fig.canvas.draw()
        labels0 = [item.get_text() for item in ax0.get_yticklabels()]
        labels0[0] = u''
        ax0.set_yticklabels(labels0)
        pdfPages.savefig(fig)
 
        return
 

plotRelativeBiasACoeffs()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.plotRelativeBiasACoeffs (   aDict,   aDictNoB,   fullCovsModel,   fullCovsModelNoB,   signalElectrons,   gainDict,   pdfPages,   maxr = None  )

static

Fig. 15 in Astier+19.

Illustrates systematic bias from estimating 'a'
coefficients from the slope of correlations as opposed to the
full model in Astier+19.

Parameters
----------
aDict: `dict`
    Dictionary of 'a' matrices (Eq. 20, Astier+19), with amp names as keys.

aDictNoB: `dict`
    Dictionary of 'a' matrices ('b'= 0 in Eq. 20, Astier+19), with amp names as keys.

fullCovsModel : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing covariances model per mean flux.

fullCovsModelNoB : `dict`, [`str`, `list`]
    Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of
    Astier+19) per mean flux.

signalElectrons : `float`
    Signal at which to evaluate the a_ij coefficients.

pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
    PDF file where the plots will be saved.

gainDict : `dict`, [`str`, `float`]
    Dicgionary keyed by amp names with the gains in e-/ADU.

maxr : `int`, optional
    Maximum lag.

Definition at line 788 of file plotPtc.py.

    def plotRelativeBiasACoeffs(aDict, aDictNoB, fullCovsModel, fullCovsModelNoB, signalElectrons,
                                gainDict, pdfPages, maxr=None):
        """Fig. 15 in Astier+19.
 
        Illustrates systematic bias from estimating 'a'
        coefficients from the slope of correlations as opposed to the
        full model in Astier+19.
 
        Parameters
        ----------
        aDict: `dict`
            Dictionary of 'a' matrices (Eq. 20, Astier+19), with amp names as keys.
 
        aDictNoB: `dict`
            Dictionary of 'a' matrices ('b'= 0 in Eq. 20, Astier+19), with amp names as keys.
 
        fullCovsModel : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing covariances model per mean flux.
 
        fullCovsModelNoB : `dict`, [`str`, `list`]
            Dictionary keyed by amp names containing covariances model (with 'b'=0 in Eq. 20 of
            Astier+19) per mean flux.
 
        signalElectrons : `float`
            Signal at which to evaluate the a_ij coefficients.
 
        pdfPages: `matplotlib.backends.backend_pdf.PdfPages`
            PDF file where the plots will be saved.
 
        gainDict : `dict`, [`str`, `float`]
            Dicgionary keyed by amp names with the gains in e-/ADU.
 
        maxr : `int`, optional
            Maximum lag.
        """
 
        fig = plt.figure(figsize=(7, 11))
        title = [f"'a' relative bias at {signalElectrons} e", "'a' relative bias (b=0)"]
        data = [(aDict, fullCovsModel), (aDictNoB, fullCovsModelNoB)]
 
        for k, pair in enumerate(data):
            diffs = []
            amean = []
            for amp in pair[0]:
                covModel = pair[1][amp]
                if np.isnan(covModel).all():
                    continue
                aOld = computeApproximateAcoeffs(covModel, signalElectrons, gainDict[amp])
                a = pair[0][amp]
                amean.append(a)
                diffs.append((aOld-a))
            amean = np.array(amean).mean(axis=0)
            diff = np.array(diffs).mean(axis=0)
            diff = diff/amean
            diff = diff[:]
            # The difference should be close to zero
            diff[0, 0] = 0
            if maxr is None:
                maxr = diff.shape[0]
            diff = diff[:maxr, :maxr]
            ax0 = fig.add_subplot(2, 1, k+1)
            im0 = ax0.imshow(diff.transpose(), origin='lower')
            ax0.yaxis.set_major_locator(MaxNLocator(integer=True))
            ax0.xaxis.set_major_locator(MaxNLocator(integer=True))
            ax0.tick_params(axis='both', labelsize='x-large')
            plt.colorbar(im0)
            ax0.set_title(title[k])
 
        plt.tight_layout()
        pdfPages.savefig(fig)
 
        return
 

run()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.run	(		self,
			filenameFull,
			datasetPtc,
			linearizer = None,
			log = None
	)

Make the plots for the PTC task

Definition at line 139 of file plotPtc.py.

    def run(self, filenameFull, datasetPtc, linearizer=None, log=None):
        """Make the plots for the PTC task"""
        ptcFitType = datasetPtc.ptcFitType
        with PdfPages(filenameFull) as pdfPages:
            if ptcFitType in ["FULLCOVARIANCE", ]:
                self.covAstierMakeAllPlots(datasetPtc, pdfPages, log=log)
            elif ptcFitType in ["EXPAPPROXIMATION", "POLYNOMIAL"]:
                self._plotStandardPtc(datasetPtc, ptcFitType, pdfPages)
            else:
                raise RuntimeError(f"The input dataset had an invalid dataset.ptcFitType: {ptcFitType}. \n" +
                                   "Options: 'FULLCOVARIANCE', EXPAPPROXIMATION, or 'POLYNOMIAL'.")
            if linearizer:
                self._plotLinearizer(datasetPtc, linearizer, pdfPages)
 
        return
 

runDataRef()

def lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.runDataRef	(		self,
			dataRef
	)

Run the Photon Transfer Curve (PTC) plotting measurement task.

Parameters
----------
dataRef : list of lsst.daf.persistence.ButlerDataRef
    dataRef for the detector for the expIds to be fit.

Definition at line 111 of file plotPtc.py.

    def runDataRef(self, dataRef):
        """Run the Photon Transfer Curve (PTC) plotting measurement task.
 
        Parameters
        ----------
        dataRef : list of lsst.daf.persistence.ButlerDataRef
            dataRef for the detector for the expIds to be fit.
        """
 
        datasetFile = self.config.datasetFileName
        datasetPtc = PhotonTransferCurveDataset.readFits(datasetFile)
 
        dirname = dataRef.getUri(datasetType='cpPipePlotRoot', write=True)
        if not os.path.exists(dirname):
            os.makedirs(dirname)
 
        detNum = dataRef.dataId[self.config.ccdKey]
        filename = f"PTC_det{detNum}.pdf"
        filenameFull = os.path.join(dirname, filename)
 
        if self.config.linearizerFileName:
            linearizer = isr.linearize.Linearizer.readFits(self.config.linearizerFileName)
        else:
            linearizer = None
        self.run(filenameFull, datasetPtc, linearizer=linearizer, log=self.log)
 
        return pipeBase.Struct(exitStatus=0)
 

Member Data Documentation

ConfigClass

lsst.cp.pipe.plotPtc.PlotPhotonTransferCurveTask.ConfigClass = PlotPhotonTransferCurveTaskConfig

static

Definition at line 92 of file plotPtc.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/plotPtc.py