Inheritance diagram for lsst.ip.diffim.zogy.ZogyMapper:

Public Member Functions
def	__init__ (self, args, *kwargs)

def	run (self, subExposure, expandedSubExposure, fullBBox, template, **kwargs)

def	setup (self, templateExposure=None, scienceExposure=None, sig1=None, sig2=None, psf1=None, psf2=None, correctBackground=False, args, *kwargs)

def	computePrereqs (self, psf1=None, psf2=None, padSize=0)

def	computeDiffimFourierSpace (self, debug=False, returnMatchedTemplate=False, **kwargs)

def	computeDiffimImageSpace (self, padSize=None, debug=False, **kwargs)

def	computeDiffim (self, inImageSpace=None, padSize=None, returnMatchedTemplate=False, **kwargs)

def	computeDiffimPsf (self, padSize=0, keepFourier=False, psf1=None, psf2=None)

def	computeScorrFourierSpace (self, xVarAst=0., yVarAst=0., **kwargs)

def	computeScorrImageSpace (self, xVarAst=0., yVarAst=0., padSize=None, **kwargs)

def	computeScorr (self, xVarAst=0., yVarAst=0., inImageSpace=None, padSize=0, **kwargs)

def	run (self, subExposure, expandedSubExposure, fullBBox, **kwargs)

Public Attributes
	template

	science

	statsControl

	im1

	im2

	im1_var

	im2_var

	im1_psf

	im2_psf

	sig1

	sig2

	Fr

	Fn

	padSize

Static Public Attributes
	ConfigClass = ZogyConfig

Detailed Description

Task to be used as an ImageMapper for performing
ZOGY image subtraction on a grid of subimages.

Definition at line 927 of file zogy.py.

Constructor & Destructor Documentation

◆ init()

def lsst.ip.diffim.zogy.ZogyMapper.__init__	(		self,
		*	args,
		**	kwargs
	)

Definition at line 934 of file zogy.py.

     def __init__(self, *args, **kwargs):
         ImageMapper.__init__(self, *args, **kwargs)
  

Member Function Documentation

◆ computeDiffim()

def lsst.ip.diffim.zogy.ZogyTask.computeDiffim	(		self,
			inImageSpace = `None`,
			padSize = `None`,
			returnMatchedTemplate = `False`,
		**	kwargs
	)

inherited

Wrapper method to compute ZOGY proper diffim

This method should be used as the public interface for
computing the ZOGY diffim.

Parameters
----------
inImageSpace : `bool`
   Override config `inImageSpace` parameter
padSize : `int`
   Override config `padSize` parameter
returnMatchedTemplate : `bool`
   Include the PSF-matched template in the results Struct
**kwargs
    additional keyword arguments to be passed to
    `computeDiffimFourierSpace` or `computeDiffimImageSpace`.

Returns
-------
An lsst.pipe.base.Struct containing:
   - D : `lsst.afw.Exposure`
       the proper image difference, including correct variance,
       masks, and PSF
   - R : `lsst.afw.Exposure`
       If `returnMatchedTemplate` is True, the PSF-matched template
       exposure

Definition at line 610 of file zogy.py.

     def computeDiffim(self, inImageSpace=None, padSize=None,
                       returnMatchedTemplate=False, **kwargs):
         """Wrapper method to compute ZOGY proper diffim
  
         This method should be used as the public interface for
         computing the ZOGY diffim.
  
         Parameters
         ----------
         inImageSpace : `bool`
            Override config `inImageSpace` parameter
         padSize : `int`
            Override config `padSize` parameter
         returnMatchedTemplate : `bool`
            Include the PSF-matched template in the results Struct
         **kwargs
             additional keyword arguments to be passed to
             `computeDiffimFourierSpace` or `computeDiffimImageSpace`.
  
         Returns
         -------
         An lsst.pipe.base.Struct containing:
            - D : `lsst.afw.Exposure`
                the proper image difference, including correct variance,
                masks, and PSF
            - R : `lsst.afw.Exposure`
                If `returnMatchedTemplate` is True, the PSF-matched template
                exposure
         """
         R = None
         inImageSpace = self.config.inImageSpace if inImageSpace is None else inImageSpace
         if inImageSpace:
             padSize = self.padSize if padSize is None else padSize
             res = self.computeDiffimImageSpace(padSize=padSize, **kwargs)
             D = res.D
             if returnMatchedTemplate:
                 R = res.R
         else:
             res = self.computeDiffimFourierSpace(**kwargs)
             D = self.science.clone()
             D.getMaskedImage().getImage().getArray()[:, :] = res.D
             D.getMaskedImage().getVariance().getArray()[:, :] = res.D_var
             if returnMatchedTemplate:
                 R = self.science.clone()
                 R.getMaskedImage().getImage().getArray()[:, :] = res.R
                 R.getMaskedImage().getVariance().getArray()[:, :] = res.R_var
  
         psf = self.computeDiffimPsf()
         D = self._setNewPsf(D, psf)
         return pipeBase.Struct(D=D, R=R)
  

◆ computeDiffimFourierSpace()

def lsst.ip.diffim.zogy.ZogyTask.computeDiffimFourierSpace	(		self,
			debug = `False`,
			returnMatchedTemplate = `False`,
		**	kwargs
	)

inherited

Compute ZOGY diffim `D` as proscribed in ZOGY (2016) manuscript

Parameters
----------
debug : `bool`, optional
    If set to True, filter the kernels by setting the edges to zero.
returnMatchedTemplate : `bool`, optional
    Calculate the template image.
    If not set, the returned template will be None.

Notes
-----
In all functions, im1 is R (reference, or template) and im2 is N (new, or science)
Compute the ZOGY eqn. (13):

.. math::

    \widehat{D} = \frac{Fr\widehat{Pr}\widehat{N} -
    F_n\widehat{Pn}\widehat{R}}{\sqrt{\sigma_n^2 Fr^2
    \|\widehat{Pr}\|^2 + \sigma_r^2 F_n^2 \|\widehat{Pn}\|^2}}

where :math:`D` is the optimal difference image, :math:`R` and :math:`N` are the
reference and "new" image, respectively, :math:`Pr` and :math:`P_n` are their
PSFs, :math:`Fr` and :math:`Fn` are their flux-based zero-points (which we
will set to one here), :math:`\sigma_r^2` and :math:`\sigma_n^2` are their
variance, and :math:`\widehat{D}` denotes the FT of :math:`D`.

Returns
-------
result : `lsst.pipe.base.Struct`
    Result struct with components:

    - ``D`` : 2D `numpy.array`, the proper image difference
    - ``D_var`` : 2D `numpy.array`, the variance image for `D`

Definition at line 406 of file zogy.py.

     def computeDiffimFourierSpace(self, debug=False, returnMatchedTemplate=False, **kwargs):
         r"""Compute ZOGY diffim `D` as proscribed in ZOGY (2016) manuscript
  
         Parameters
         ----------
         debug : `bool`, optional
             If set to True, filter the kernels by setting the edges to zero.
         returnMatchedTemplate : `bool`, optional
             Calculate the template image.
             If not set, the returned template will be None.
  
         Notes
         -----
         In all functions, im1 is R (reference, or template) and im2 is N (new, or science)
         Compute the ZOGY eqn. (13):
  
         .. math::
  
             \widehat{D} = \frac{Fr\widehat{Pr}\widehat{N} -
             F_n\widehat{Pn}\widehat{R}}{\sqrt{\sigma_n^2 Fr^2
             \|\widehat{Pr}\|^2 + \sigma_r^2 F_n^2 \|\widehat{Pn}\|^2}}
  
         where :math:`D` is the optimal difference image, :math:`R` and :math:`N` are the
         reference and "new" image, respectively, :math:`Pr` and :math:`P_n` are their
         PSFs, :math:`Fr` and :math:`Fn` are their flux-based zero-points (which we
         will set to one here), :math:`\sigma_r^2` and :math:`\sigma_n^2` are their
         variance, and :math:`\widehat{D}` denotes the FT of :math:`D`.
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Result struct with components:
  
             - ``D`` : 2D `numpy.array`, the proper image difference
             - ``D_var`` : 2D `numpy.array`, the variance image for `D`
         """
         # Do all in fourier space (needs image-sized PSFs)
         psf1 = ZogyTask._padPsfToSize(self.im1_psf, self.im1.shape)
         psf2 = ZogyTask._padPsfToSize(self.im2_psf, self.im2.shape)
  
         preqs = self.computePrereqs(psf1, psf2, padSize=0)  # already padded the PSFs
  
         def _filterKernel(K, trim_amount):
             # Filter the wings of Kn, Kr, set to zero
             ps = trim_amount
             K[:ps, :] = K[-ps:, :] = 0
             K[:, :ps] = K[:, -ps:] = 0
             return K
  
         Kr_hat = self.Fr * preqs.Pr_hat / preqs.denom
         Kn_hat = self.Fn * preqs.Pn_hat / preqs.denom
         if debug and self.config.doTrimKernels:  # default False
             # Suggestion from Barak to trim Kr and Kn to remove artifacts
             # Here we just filter them (in image space) to keep them the same size
             ps = (Kn_hat.shape[1] - 80)//2
             Kn = _filterKernel(np.fft.ifft2(Kn_hat), ps)
             Kn_hat = np.fft.fft2(Kn)
             Kr = _filterKernel(np.fft.ifft2(Kr_hat), ps)
             Kr_hat = np.fft.fft2(Kr)
  
         def processImages(im1, im2, doAdd=False):
             # Some masked regions are NaN or infinite!, and FFTs no likey.
             im1[np.isinf(im1)] = np.nan
             im1[np.isnan(im1)] = np.nanmean(im1)
             im2[np.isinf(im2)] = np.nan
             im2[np.isnan(im2)] = np.nanmean(im2)
  
             R_hat = np.fft.fft2(im1)
             N_hat = np.fft.fft2(im2)
  
             D_hat = Kr_hat * N_hat
             D_hat_R = Kn_hat * R_hat
             if not doAdd:
                 D_hat -= D_hat_R
             else:
                 D_hat += D_hat_R
  
             D = np.fft.ifft2(D_hat)
             D = np.fft.ifftshift(D.real) / preqs.Fd
  
             R = None
             if returnMatchedTemplate:
                 R = np.fft.ifft2(D_hat_R)
                 R = np.fft.ifftshift(R.real) / preqs.Fd
  
             return D, R
  
         # First do the image
         D, R = processImages(self.im1, self.im2, doAdd=False)
         # Do the exact same thing to the var images, except add them
         D_var, R_var = processImages(self.im1_var, self.im2_var, doAdd=True)
  
         return pipeBase.Struct(D=D, D_var=D_var, R=R, R_var=R_var)
  

◆ computeDiffimImageSpace()

def lsst.ip.diffim.zogy.ZogyTask.computeDiffimImageSpace	(		self,
			padSize = `None`,
			debug = `False`,
		**	kwargs
	)

inherited

Compute ZOGY diffim `D` using image-space convlutions

This method is still being debugged as it results in artifacts
when the PSFs are noisy (see module-level docstring). Thus
there are several options still enabled by the `debug` flag,
which are disabled by defult.

Parameters
----------
padSize : `int`
   The amount to pad the PSFs by
debug : `bool`
   Flag to enable debugging tests and options

Returns
-------
D : `lsst.afw.Exposure`
   the proper image difference, including correct variance,
   masks, and PSF

Definition at line 540 of file zogy.py.

     def computeDiffimImageSpace(self, padSize=None, debug=False, **kwargs):
         """Compute ZOGY diffim `D` using image-space convlutions
  
         This method is still being debugged as it results in artifacts
         when the PSFs are noisy (see module-level docstring). Thus
         there are several options still enabled by the `debug` flag,
         which are disabled by defult.
  
         Parameters
         ----------
         padSize : `int`
            The amount to pad the PSFs by
         debug : `bool`
            Flag to enable debugging tests and options
  
         Returns
         -------
         D : `lsst.afw.Exposure`
            the proper image difference, including correct variance,
            masks, and PSF
         """
         preqs = self.computePrereqs(padSize=padSize)
  
         delta = 0.
         if debug:
             delta = 1.  # Regularize the ratio, a possible option to remove artifacts
         Kr_hat = (preqs.Pr_hat + delta) / (preqs.denom + delta)
         Kn_hat = (preqs.Pn_hat + delta) / (preqs.denom + delta)
         Kr = np.fft.ifft2(Kr_hat).real
         Kr = np.roll(np.roll(Kr, -1, 0), -1, 1)
         Kn = np.fft.ifft2(Kn_hat).real
         Kn = np.roll(np.roll(Kn, -1, 0), -1, 1)
  
         def _trimKernel(self, K, trim_amount):
             # Trim out the wings of Kn, Kr (see notebook #15)
             # only necessary if it's from a measured psf and PsfEx seems to always make PSFs of size 41x41
             ps = trim_amount
             K = K[ps:-ps, ps:-ps]
             return K
  
         padSize = self.padSize if padSize is None else padSize
         # Enabling this block (debug=True) makes it slightly faster, but ~25% worse artifacts:
         if debug and self.config.doTrimKernels:  # default False
             # Filtering also makes it slightly faster (zeros are ignored in convolution)
             # but a bit worse. Filter the wings of Kn, Kr (see notebook #15)
             Kn = _trimKernel(Kn, padSize)
             Kr = _trimKernel(Kr, padSize)
  
         # Note these are reverse-labelled, this is CORRECT!
         exp1, _ = self._doConvolve(self.template, Kn)
         exp2, _ = self._doConvolve(self.science, Kr)
         D = exp2
         tmp = D.getMaskedImage()
         tmp -= exp1.getMaskedImage()
         tmp /= preqs.Fd
         return pipeBase.Struct(D=D, R=exp1)
  

◆ computeDiffimPsf()

def lsst.ip.diffim.zogy.ZogyTask.computeDiffimPsf	(	self,
		padSize = `0`,
		keepFourier = `False`,
		psf1 = `None`,
		psf2 = `None`
	)

inherited

Compute the ZOGY diffim PSF (ZOGY manuscript eq. 14)

Parameters
----------
padSize : `int`
   Override config `padSize` parameter
keepFourier : `bool`
   Return the FFT of the diffim PSF (do not inverse-FFT it)
psf1 : 2D `numpy.array`
    (Optional) Input psf of template, override if already padded
psf2 : 2D `numpy.array`
    (Optional) Input psf of science image, override if already padded

Returns
-------
Pd : 2D `numpy.array`
    The diffim PSF (or FFT of PSF if `keepFourier=True`)

Definition at line 661 of file zogy.py.

     def computeDiffimPsf(self, padSize=0, keepFourier=False, psf1=None, psf2=None):
         """Compute the ZOGY diffim PSF (ZOGY manuscript eq. 14)
  
         Parameters
         ----------
         padSize : `int`
            Override config `padSize` parameter
         keepFourier : `bool`
            Return the FFT of the diffim PSF (do not inverse-FFT it)
         psf1 : 2D `numpy.array`
             (Optional) Input psf of template, override if already padded
         psf2 : 2D `numpy.array`
             (Optional) Input psf of science image, override if already padded
  
         Returns
         -------
         Pd : 2D `numpy.array`
             The diffim PSF (or FFT of PSF if `keepFourier=True`)
         """
         preqs = self.computePrereqs(psf1=psf1, psf2=psf2, padSize=padSize)
  
         Pd_hat_numerator = (self.Fr * self.Fn * preqs.Pr_hat * preqs.Pn_hat)
         Pd_hat = Pd_hat_numerator / (preqs.Fd * preqs.denom)
  
         if keepFourier:
             return Pd_hat
  
         Pd = np.fft.ifft2(Pd_hat)
         Pd = np.fft.ifftshift(Pd).real
  
         return Pd
  

◆ computePrereqs()

def lsst.ip.diffim.zogy.ZogyTask.computePrereqs	(	self,
		psf1 = `None`,
		psf2 = `None`,
		padSize = `0`
	)

inherited

Compute standard ZOGY quantities used by (nearly) all methods.

Many of the ZOGY calculations require similar quantities, including
FFTs of the PSFs, and the "denominator" term (e.g. in eq. 13 of
ZOGY manuscript (2016). This function consolidates many of those
operations.

Parameters
----------
psf1 : 2D `numpy.array`
    (Optional) Input psf of template, override if already padded
psf2 : 2D `numpy.array`
    (Optional) Input psf of science image, override if already padded
padSize : `int`, optional
    Number of pixels to pad the image on each side with zeroes.

Returns
-------
A `lsst.pipe.base.Struct` containing:
- Pr : 2D `numpy.array`, the (possibly zero-padded) template PSF
- Pn : 2D `numpy.array`, the (possibly zero-padded) science PSF
- Pr_hat : 2D `numpy.array`, the FFT of `Pr`
- Pn_hat : 2D `numpy.array`, the FFT of `Pn`
- denom : 2D `numpy.array`, the denominator of equation (13) in ZOGY (2016) manuscript
- Fd : `float`, the relative flux scaling factor between science and template

Definition at line 355 of file zogy.py.

     def computePrereqs(self, psf1=None, psf2=None, padSize=0):
         """Compute standard ZOGY quantities used by (nearly) all methods.
  
         Many of the ZOGY calculations require similar quantities, including
         FFTs of the PSFs, and the "denominator" term (e.g. in eq. 13 of
         ZOGY manuscript (2016). This function consolidates many of those
         operations.
  
         Parameters
         ----------
         psf1 : 2D `numpy.array`
             (Optional) Input psf of template, override if already padded
         psf2 : 2D `numpy.array`
             (Optional) Input psf of science image, override if already padded
         padSize : `int`, optional
             Number of pixels to pad the image on each side with zeroes.
  
         Returns
         -------
         A `lsst.pipe.base.Struct` containing:
         - Pr : 2D `numpy.array`, the (possibly zero-padded) template PSF
         - Pn : 2D `numpy.array`, the (possibly zero-padded) science PSF
         - Pr_hat : 2D `numpy.array`, the FFT of `Pr`
         - Pn_hat : 2D `numpy.array`, the FFT of `Pn`
         - denom : 2D `numpy.array`, the denominator of equation (13) in ZOGY (2016) manuscript
         - Fd : `float`, the relative flux scaling factor between science and template
         """
         psf1 = self.im1_psf if psf1 is None else psf1
         psf2 = self.im2_psf if psf2 is None else psf2
         padSize = self.padSize if padSize is None else padSize
         Pr, Pn = psf1, psf2
         if padSize > 0:
             Pr = ZogyTask._padPsfToSize(psf1, (psf1.shape[0] + padSize, psf1.shape[1] + padSize))
             Pn = ZogyTask._padPsfToSize(psf2, (psf2.shape[0] + padSize, psf2.shape[1] + padSize))
         # Make sure there are no div-by-zeros
         psf1[np.abs(psf1) <= MIN_KERNEL] = MIN_KERNEL
         psf2[np.abs(psf2) <= MIN_KERNEL] = MIN_KERNEL
  
         sigR, sigN = self.sig1, self.sig2
         Pr_hat = np.fft.fft2(Pr)
         Pr_hat2 = np.conj(Pr_hat) * Pr_hat
         Pn_hat = np.fft.fft2(Pn)
         Pn_hat2 = np.conj(Pn_hat) * Pn_hat
         denom = np.sqrt((sigN**2 * self.Fr**2 * Pr_hat2) + (sigR**2 * self.Fn**2 * Pn_hat2))
         Fd = self.Fr * self.Fn / np.sqrt(sigN**2 * self.Fr**2 + sigR**2 * self.Fn**2)
  
         res = pipeBase.Struct(
             Pr=Pr, Pn=Pn, Pr_hat=Pr_hat, Pn_hat=Pn_hat, denom=denom, Fd=Fd
         )
         return res
  

◆ computeScorr()

def lsst.ip.diffim.zogy.ZogyTask.computeScorr	(		self,
			xVarAst = `0.`,
			yVarAst = `0.`,
			inImageSpace = `None`,
			padSize = `0`,
		**	kwargs
	)

inherited

Wrapper method to compute ZOGY corrected likelihood image, optimal for
source detection

This method should be used as the public interface for
computing the ZOGY S_corr.

Parameters
----------
xVarAst, yVarAst : `float`
   estimated astrometric noise (variance of astrometric registration errors)
inImageSpace : `bool`
   Override config `inImageSpace` parameter
padSize : `int`
   Override config `padSize` parameter

Returns
-------
S : `lsst.afw.image.Exposure`
    The likelihood exposure S (eq. 12 of ZOGY (2016)),
    including corrected variance, masks, and PSF

Definition at line 890 of file zogy.py.

     def computeScorr(self, xVarAst=0., yVarAst=0., inImageSpace=None, padSize=0, **kwargs):
         """Wrapper method to compute ZOGY corrected likelihood image, optimal for
         source detection
  
         This method should be used as the public interface for
         computing the ZOGY S_corr.
  
         Parameters
         ----------
         xVarAst, yVarAst : `float`
            estimated astrometric noise (variance of astrometric registration errors)
         inImageSpace : `bool`
            Override config `inImageSpace` parameter
         padSize : `int`
            Override config `padSize` parameter
  
         Returns
         -------
         S : `lsst.afw.image.Exposure`
             The likelihood exposure S (eq. 12 of ZOGY (2016)),
             including corrected variance, masks, and PSF
         """
         inImageSpace = self.config.inImageSpace if inImageSpace is None else inImageSpace
         if inImageSpace:
             res = self.computeScorrImageSpace(xVarAst=xVarAst, yVarAst=yVarAst, padSize=padSize)
             S = res.S
         else:
             res = self.computeScorrFourierSpace(xVarAst=xVarAst, yVarAst=yVarAst)
  
             S = self.science.clone()
             S.getMaskedImage().getImage().getArray()[:, :] = res.S
             S.getMaskedImage().getVariance().getArray()[:, :] = res.S_var
             S = self._setNewPsf(S, res.Dpsf)
  
         return pipeBase.Struct(S=S)
  
  

◆ computeScorrFourierSpace()

def lsst.ip.diffim.zogy.ZogyTask.computeScorrFourierSpace	(		self,
			xVarAst = `0.`,
			yVarAst = `0.`,
		**	kwargs
	)

inherited

Compute corrected likelihood image, optimal for source detection

Compute ZOGY S_corr image. This image can be thresholded for
detection without optimal filtering, and the variance image is
corrected to account for astrometric noise (errors in
astrometric registration whether systematic or due to effects
such as DCR). The calculations here are all performed in
Fourier space, as proscribed in ZOGY (2016).

Parameters
----------
xVarAst, yVarAst : `float`
   estimated astrometric noise (variance of astrometric registration errors)

Returns
-------
result : `lsst.pipe.base.Struct`
    Result struct with components:

    - ``S`` : `numpy.array`, the likelihood image S (eq. 12 of ZOGY (2016))
    - ``S_var`` : the corrected variance image (denominator of eq. 25 of ZOGY (2016))
    - ``Dpsf`` : the PSF of the diffim D, likely never to be used.

Definition at line 748 of file zogy.py.

     def computeScorrFourierSpace(self, xVarAst=0., yVarAst=0., **kwargs):
         """Compute corrected likelihood image, optimal for source detection
  
         Compute ZOGY S_corr image. This image can be thresholded for
         detection without optimal filtering, and the variance image is
         corrected to account for astrometric noise (errors in
         astrometric registration whether systematic or due to effects
         such as DCR). The calculations here are all performed in
         Fourier space, as proscribed in ZOGY (2016).
  
         Parameters
         ----------
         xVarAst, yVarAst : `float`
            estimated astrometric noise (variance of astrometric registration errors)
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Result struct with components:
  
             - ``S`` : `numpy.array`, the likelihood image S (eq. 12 of ZOGY (2016))
             - ``S_var`` : the corrected variance image (denominator of eq. 25 of ZOGY (2016))
             - ``Dpsf`` : the PSF of the diffim D, likely never to be used.
         """
         # Some masked regions are NaN or infinite!, and FFTs no likey.
         def fix_nans(im):
             """Replace any NaNs or Infs with the mean of the image."""
             isbad = ~np.isfinite(im)
             if np.any(isbad):
                 im[isbad] = np.nan
                 im[isbad] = np.nanmean(im)
             return im
  
         self.im1 = fix_nans(self.im1)
         self.im2 = fix_nans(self.im2)
         self.im1_var = fix_nans(self.im1_var)
         self.im2_var = fix_nans(self.im2_var)
  
         # Do all in fourier space (needs image-sized PSFs)
         psf1 = ZogyTask._padPsfToSize(self.im1_psf, self.im1.shape)
         psf2 = ZogyTask._padPsfToSize(self.im2_psf, self.im2.shape)
  
         preqs = self.computePrereqs(psf1, psf2, padSize=0)  # already padded the PSFs
  
         # Compute D_hat here (don't need D then, for speed)
         R_hat = np.fft.fft2(self.im1)
         N_hat = np.fft.fft2(self.im2)
         D_hat = self.Fr * preqs.Pr_hat * N_hat - self.Fn * preqs.Pn_hat * R_hat
         D_hat /= preqs.denom
  
         Pd_hat = self.computeDiffimPsf(padSize=0, keepFourier=True, psf1=psf1, psf2=psf2)
         Pd_bar = np.conj(Pd_hat)
         S = np.fft.ifft2(D_hat * Pd_bar)
  
         # Adjust the variance planes of the two images to contribute to the final detection
         # (eq's 26-29).
         Pn_hat2 = np.conj(preqs.Pn_hat) * preqs.Pn_hat
         Kr_hat = self.Fr * self.Fn**2. * np.conj(preqs.Pr_hat) * Pn_hat2 / preqs.denom**2.
         Pr_hat2 = np.conj(preqs.Pr_hat) * preqs.Pr_hat
         Kn_hat = self.Fn * self.Fr**2. * np.conj(preqs.Pn_hat) * Pr_hat2 / preqs.denom**2.
  
         Kr_hat2 = np.fft.fft2(np.fft.ifft2(Kr_hat)**2.)
         Kn_hat2 = np.fft.fft2(np.fft.ifft2(Kn_hat)**2.)
         var1c_hat = Kr_hat2 * np.fft.fft2(self.im1_var)
         var2c_hat = Kn_hat2 * np.fft.fft2(self.im2_var)
  
         # Do the astrometric variance correction
         fGradR, fGradN = self._computeVarAstGradients(xVarAst, yVarAst, inImageSpace=False,
                                                       R_hat=R_hat, Kr_hat=Kr_hat,
                                                       N_hat=N_hat, Kn_hat=Kn_hat)
  
         S_var = np.sqrt(np.fft.ifftshift(np.fft.ifft2(var1c_hat + var2c_hat)) + fGradR + fGradN)
         S_var *= preqs.Fd
  
         S = np.fft.ifftshift(np.fft.ifft2(Kn_hat * N_hat - Kr_hat * R_hat))
         S *= preqs.Fd
  
         Pd = self.computeDiffimPsf(padSize=0)
         return pipeBase.Struct(S=S.real, S_var=S_var.real, Dpsf=Pd)
  

◆ computeScorrImageSpace()

def lsst.ip.diffim.zogy.ZogyTask.computeScorrImageSpace	(		self,
			xVarAst = `0.`,
			yVarAst = `0.`,
			padSize = `None`,
		**	kwargs
	)

inherited

Compute corrected likelihood image, optimal for source detection

Compute ZOGY S_corr image. This image can be thresholded for
detection without optimal filtering, and the variance image is
corrected to account for astrometric noise (errors in
astrometric registration whether systematic or due to effects
such as DCR). The calculations here are all performed in
Real (image) space.

Parameters
----------
xVarAst, yVarAst : `float`
   estimated astrometric noise (variance of astrometric registration errors)

Returns
-------
A `lsst.pipe.base.Struct` containing:
- S : `lsst.afw.image.Exposure`, the likelihood exposure S (eq. 12 of ZOGY (2016)),
    including corrected variance, masks, and PSF
- D : `lsst.afw.image.Exposure`, the proper image difference, including correct
    variance, masks, and PSF

Definition at line 828 of file zogy.py.

     def computeScorrImageSpace(self, xVarAst=0., yVarAst=0., padSize=None, **kwargs):
         """Compute corrected likelihood image, optimal for source detection
  
         Compute ZOGY S_corr image. This image can be thresholded for
         detection without optimal filtering, and the variance image is
         corrected to account for astrometric noise (errors in
         astrometric registration whether systematic or due to effects
         such as DCR). The calculations here are all performed in
         Real (image) space.
  
         Parameters
         ----------
         xVarAst, yVarAst : `float`
            estimated astrometric noise (variance of astrometric registration errors)
  
         Returns
         -------
         A `lsst.pipe.base.Struct` containing:
         - S : `lsst.afw.image.Exposure`, the likelihood exposure S (eq. 12 of ZOGY (2016)),
             including corrected variance, masks, and PSF
         - D : `lsst.afw.image.Exposure`, the proper image difference, including correct
             variance, masks, and PSF
         """
         # Do convolutions in image space
         preqs = self.computePrereqs(padSize=0)
  
         padSize = self.padSize if padSize is None else padSize
         D = self.computeDiffimImageSpace(padSize=padSize).D
         Pd = self.computeDiffimPsf()
         D = self._setNewPsf(D, Pd)
         Pd_bar = np.fliplr(np.flipud(Pd))
         S, _ = self._doConvolve(D, Pd_bar)
         tmp = S.getMaskedImage()
         tmp *= preqs.Fd
  
         # Adjust the variance planes of the two images to contribute to the final detection
         # (eq's 26-29).
         Pn_hat2 = np.conj(preqs.Pn_hat) * preqs.Pn_hat
         Kr_hat = self.Fr * self.Fn**2. * np.conj(preqs.Pr_hat) * Pn_hat2 / preqs.denom**2.
         Pr_hat2 = np.conj(preqs.Pr_hat) * preqs.Pr_hat
         Kn_hat = self.Fn * self.Fr**2. * np.conj(preqs.Pn_hat) * Pr_hat2 / preqs.denom**2.
  
         Kr = np.fft.ifft2(Kr_hat).real
         Kr = np.roll(np.roll(Kr, -1, 0), -1, 1)
         Kn = np.fft.ifft2(Kn_hat).real
         Kn = np.roll(np.roll(Kn, -1, 0), -1, 1)
         var1c, _ = self._doConvolve(self.template.getMaskedImage().getVariance(), Kr**2.)
         var2c, _ = self._doConvolve(self.science.getMaskedImage().getVariance(), Kn**2.)
  
         # Do the astrometric variance correction
         fGradR, fGradN = self._computeVarAstGradients(xVarAst, yVarAst, inImageSpace=True,
                                                       Kr=Kr, Kn=Kn)
  
         Smi = S.getMaskedImage()
         Smi *= preqs.Fd
         S_var = np.sqrt(var1c.getArray() + var2c.getArray() + fGradR + fGradN)
         S.getMaskedImage().getVariance().getArray()[:, :] = S_var
         S = self._setNewPsf(S, Pd)
  
         # also return diffim since it was calculated and might be desired
         return pipeBase.Struct(S=S, D=D)
  

◆ run() [1/2]

def lsst.ip.diffim.imageMapReduce.ImageMapper.run	(		self,
			subExposure,
			expandedSubExposure,
			fullBBox,
		**	kwargs
	)

inherited

Perform operation on `subExposure`.

To be implemented by subclasses. See class docstring for more
details. This method is given the `subExposure` which
is to be operated upon, and an `expandedSubExposure` which
will contain `subExposure` with additional surrounding
pixels. This allows for, for example, convolutions (which
should be performed on `expandedSubExposure`), to prevent the
returned sub-exposure from containing invalid pixels.

This method may return a new, processed sub-exposure which can
be be "stitched" back into a new resulting larger exposure
(depending on the paired, configured `ImageReducer`);
otherwise if it does not return an lsst.afw.image.Exposure, then the
`ImageReducer.config.mapper.reduceOperation`
should be set to 'none' and the result will be propagated
as-is.

Parameters
----------
subExposure : `lsst.afw.image.Exposure`
    the sub-exposure upon which to operate
expandedSubExposure : `lsst.afw.image.Exposure`
    the expanded sub-exposure upon which to operate
fullBBox : `lsst.geom.Box2I`
    the bounding box of the original exposure
kwargs :
    additional keyword arguments propagated from
    `ImageMapReduceTask.run`.

Returns
-------
result : `lsst.pipe.base.Struct`
    A structure containing the result of the `subExposure` processing,
    which may itself be of any type. See above for details. If it is an
    `lsst.afw.image.Exposure` (processed sub-exposure), then the name in
    the Struct should be 'subExposure'. This is implemented here as a
    pass-through example only.

Definition at line 109 of file imageMapReduce.py.

     def run(self, subExposure, expandedSubExposure, fullBBox, **kwargs):
         """Perform operation on `subExposure`.
  
         To be implemented by subclasses. See class docstring for more
         details. This method is given the `subExposure` which
         is to be operated upon, and an `expandedSubExposure` which
         will contain `subExposure` with additional surrounding
         pixels. This allows for, for example, convolutions (which
         should be performed on `expandedSubExposure`), to prevent the
         returned sub-exposure from containing invalid pixels.
  
         This method may return a new, processed sub-exposure which can
         be be "stitched" back into a new resulting larger exposure
         (depending on the paired, configured `ImageReducer`);
         otherwise if it does not return an lsst.afw.image.Exposure, then the
         `ImageReducer.config.mapper.reduceOperation`
         should be set to 'none' and the result will be propagated
         as-is.
  
         Parameters
         ----------
         subExposure : `lsst.afw.image.Exposure`
             the sub-exposure upon which to operate
         expandedSubExposure : `lsst.afw.image.Exposure`
             the expanded sub-exposure upon which to operate
         fullBBox : `lsst.geom.Box2I`
             the bounding box of the original exposure
         kwargs :
             additional keyword arguments propagated from
             `ImageMapReduceTask.run`.
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             A structure containing the result of the `subExposure` processing,
             which may itself be of any type. See above for details. If it is an
             `lsst.afw.image.Exposure` (processed sub-exposure), then the name in
             the Struct should be 'subExposure'. This is implemented here as a
             pass-through example only.
         """
         return pipeBase.Struct(subExposure=subExposure)
  
  

◆ run() [2/2]

def lsst.ip.diffim.zogy.ZogyMapper.run	(		self,
			subExposure,
			expandedSubExposure,
			fullBBox,
			template,
		**	kwargs
	)

Perform ZOGY proper image subtraction on sub-images

This method performs ZOGY proper image subtraction on
`subExposure` using local measures for image variances and
PSF. `subExposure` is a sub-exposure of the science image. It
also requires the corresponding sub-exposures of the template
(`template`). The operations are actually performed on
`expandedSubExposure` to allow for invalid edge pixels arising
from convolutions, which are then removed.

Parameters
----------
subExposure : `lsst.afw.image.Exposure`
    the sub-exposure of the diffim
expandedSubExposure : `lsst.afw.image.Exposure`
    the expanded sub-exposure upon which to operate
fullBBox : `lsst.geom.Box2I`
    the bounding box of the original exposure
template : `lsst.afw.image.Exposure`
    the template exposure, from which a corresponding sub-exposure
    is extracted
**kwargs
    additional keyword arguments propagated from
    `ImageMapReduceTask.run`. These include:

    ``doScorr`` : `bool`
Compute and return the corrected likelihood image S_corr
rather than the proper image difference
    ``inImageSpace`` : `bool`
Perform all convolutions in real (image) space rather than
in Fourier space. This option currently leads to artifacts
when using real (measured and noisy) PSFs, thus it is set
to `False` by default.
These kwargs may also include arguments to be propagated to
`ZogyTask.computeDiffim` and `ZogyTask.computeScorr`.

Returns
-------
result : `lsst.pipe.base.Struct`
    Result struct with components:

``subExposure``: Either the subExposure of the proper image difference ``D``,
    or (if `doScorr==True`) the corrected likelihood exposure ``S``.

Notes
-----
This `run` method accepts parameters identical to those of
`ImageMapper.run`, since it is called from the
`ImageMapperTask`. See that class for more information.

Definition at line 937 of file zogy.py.

     def run(self, subExposure, expandedSubExposure, fullBBox, template,
             **kwargs):
         """Perform ZOGY proper image subtraction on sub-images
  
         This method performs ZOGY proper image subtraction on
         `subExposure` using local measures for image variances and
         PSF. `subExposure` is a sub-exposure of the science image. It
         also requires the corresponding sub-exposures of the template
         (`template`). The operations are actually performed on
         `expandedSubExposure` to allow for invalid edge pixels arising
         from convolutions, which are then removed.
  
         Parameters
         ----------
         subExposure : `lsst.afw.image.Exposure`
             the sub-exposure of the diffim
         expandedSubExposure : `lsst.afw.image.Exposure`
             the expanded sub-exposure upon which to operate
         fullBBox : `lsst.geom.Box2I`
             the bounding box of the original exposure
         template : `lsst.afw.image.Exposure`
             the template exposure, from which a corresponding sub-exposure
             is extracted
         **kwargs
             additional keyword arguments propagated from
             `ImageMapReduceTask.run`. These include:
  
             ``doScorr`` : `bool`
                 Compute and return the corrected likelihood image S_corr
                 rather than the proper image difference
             ``inImageSpace`` : `bool`
                 Perform all convolutions in real (image) space rather than
                 in Fourier space. This option currently leads to artifacts
                 when using real (measured and noisy) PSFs, thus it is set
                 to `False` by default.
                 These kwargs may also include arguments to be propagated to
                 `ZogyTask.computeDiffim` and `ZogyTask.computeScorr`.
  
         Returns
         -------
         result : `lsst.pipe.base.Struct`
             Result struct with components:
  
                 ``subExposure``: Either the subExposure of the proper image difference ``D``,
                     or (if `doScorr==True`) the corrected likelihood exposure ``S``.
  
         Notes
         -----
         This `run` method accepts parameters identical to those of
         `ImageMapper.run`, since it is called from the
         `ImageMapperTask`. See that class for more information.
         """
         bbox = subExposure.getBBox()
         center = ((bbox.getBeginX() + bbox.getEndX()) // 2., (bbox.getBeginY() + bbox.getEndY()) // 2.)
         center = geom.Point2D(center[0], center[1])
  
         imageSpace = kwargs.pop('inImageSpace', False)
         doScorr = kwargs.pop('doScorr', False)
         sigmas = kwargs.pop('sigmas', None)
         padSize = kwargs.pop('padSize', 7)
  
         # Psf and image for science img (index 2)
         subExp2 = expandedSubExposure
  
         # Psf and image for template img (index 1)
         subExp1 = template.Factory(template, expandedSubExposure.getBBox())
  
         if sigmas is None:
             sig1 = sig2 = None
         else:
             # for testing, can use the input sigma (e.g., global value for entire exposure)
             sig1, sig2 = sigmas[0], sigmas[1]
  
         def _makePsfSquare(psf):
             # Sometimes CoaddPsf does this. Make it square.
             if psf.shape[0] < psf.shape[1]:
                 psf = np.pad(psf, ((0, psf.shape[1] - psf.shape[0]), (0, 0)), mode='constant',
                              constant_values=0.)
             elif psf.shape[0] > psf.shape[1]:
                 psf = np.pad(psf, ((0, 0), (0, psf.shape[0] - psf.shape[1])), mode='constant',
                              constant_values=0.)
             return psf
  
         psf2 = subExp2.getPsf().computeKernelImage(center).getArray()
         psf2 = _makePsfSquare(psf2)
  
         psf1 = template.getPsf().computeKernelImage(center).getArray()
         psf1 = _makePsfSquare(psf1)
  
         # from diffimTests.diffimTests ...
         if subExp1.getDimensions()[0] < psf1.shape[0] or subExp1.getDimensions()[1] < psf1.shape[1]:
             return pipeBase.Struct(subExposure=subExposure)
  
         def _filterPsf(psf):
             """Filter a noisy Psf to remove artifacts. Subject of future research."""
             # only necessary if it's from a measured psf and PsfEx seems to always make PSFs of size 41x41
             if psf.shape[0] == 41:  # its from a measured psf
                 psf = psf.copy()
                 psf[psf < 0] = 0
                 psf[0:10, :] = psf[:, 0:10] = psf[31:41, :] = psf[:, 31:41] = 0
                 psf /= psf.sum()
  
             return psf
  
         psf1b = psf2b = None
         if self.config.doFilterPsfs:  # default True
             # Note this *really* helps for measured psfs.
             psf1b = _filterPsf(psf1)
             psf2b = _filterPsf(psf2)
  
         config = ZogyConfig()
         if imageSpace is True:
             config.inImageSpace = imageSpace
             config.padSize = padSize  # Don't need padding if doing all in fourier space
         task = ZogyTask(templateExposure=subExp1, scienceExposure=subExp2,
                         sig1=sig1, sig2=sig2, psf1=psf1b, psf2=psf2b, config=config)
  
         if not doScorr:
             res = task.computeDiffim(**kwargs)
             D = res.D
         else:
             res = task.computeScorr(**kwargs)
             D = res.S
  
         outExp = D.Factory(D, subExposure.getBBox())
         out = pipeBase.Struct(subExposure=outExp)
         return out
  
  

◆ setup()

def lsst.ip.diffim.zogy.ZogyTask.setup	(		self,
			templateExposure = `None`,
			scienceExposure = `None`,
			sig1 = `None`,
			sig2 = `None`,
			psf1 = `None`,
			psf2 = `None`,
			correctBackground = `False`,
		*	args,
		**	kwargs
	)

inherited

Set up the ZOGY task.

Parameters
----------
templateExposure : `lsst.afw.image.Exposure`
    Template exposure ("Reference image" in ZOGY (2016)).
scienceExposure : `lsst.afw.image.Exposure`
    Science exposure ("New image" in ZOGY (2016)). Must have already been
    registered and photometrically matched to template.
sig1 : `float`
    (Optional) sqrt(variance) of `templateExposure`. If `None`, it is
    computed from the sqrt(mean) of the `templateExposure` variance image.
sig2 : `float`
    (Optional) sqrt(variance) of `scienceExposure`. If `None`, it is
    computed from the sqrt(mean) of the `scienceExposure` variance image.
psf1 : 2D `numpy.array`
    (Optional) 2D array containing the PSF image for the template. If
    `None`, it is extracted from the PSF taken at the center of `templateExposure`.
psf2 : 2D `numpy.array`
    (Optional) 2D array containing the PSF image for the science img. If
    `None`, it is extracted from the PSF taken at the center of `scienceExposure`.
correctBackground : `bool`
    (Optional) subtract sigma-clipped mean of exposures. Zogy doesn't correct
    nonzero backgrounds (unlike AL) so subtract them here.
*args
    additional arguments to be passed to
    `lsst.pipe.base.Task`
**kwargs
    additional keyword arguments to be passed to
    `lsst.pipe.base.Task`

Definition at line 176 of file zogy.py.

     def setup(self, templateExposure=None, scienceExposure=None, sig1=None, sig2=None,
               psf1=None, psf2=None, correctBackground=False, *args, **kwargs):
         """Set up the ZOGY task.
  
         Parameters
         ----------
         templateExposure : `lsst.afw.image.Exposure`
             Template exposure ("Reference image" in ZOGY (2016)).
         scienceExposure : `lsst.afw.image.Exposure`
             Science exposure ("New image" in ZOGY (2016)). Must have already been
             registered and photometrically matched to template.
         sig1 : `float`
             (Optional) sqrt(variance) of `templateExposure`. If `None`, it is
             computed from the sqrt(mean) of the `templateExposure` variance image.
         sig2 : `float`
             (Optional) sqrt(variance) of `scienceExposure`. If `None`, it is
             computed from the sqrt(mean) of the `scienceExposure` variance image.
         psf1 : 2D `numpy.array`
             (Optional) 2D array containing the PSF image for the template. If
             `None`, it is extracted from the PSF taken at the center of `templateExposure`.
         psf2 : 2D `numpy.array`
             (Optional) 2D array containing the PSF image for the science img. If
             `None`, it is extracted from the PSF taken at the center of `scienceExposure`.
         correctBackground : `bool`
             (Optional) subtract sigma-clipped mean of exposures. Zogy doesn't correct
             nonzero backgrounds (unlike AL) so subtract them here.
         *args
             additional arguments to be passed to
             `lsst.pipe.base.Task`
         **kwargs
             additional keyword arguments to be passed to
             `lsst.pipe.base.Task`
         """
         if self.template is None and templateExposure is None:
             return
         if self.science is None and scienceExposure is None:
             return
  
         self.template = templateExposure
         self.science = scienceExposure
  
         self.statsControl = afwMath.StatisticsControl()
         self.statsControl.setNumSigmaClip(3.)
         self.statsControl.setNumIter(3)
         self.statsControl.setAndMask(afwImage.Mask.getPlaneBitMask(
             self.config.ignoreMaskPlanes))
  
         self.im1 = self.template.getMaskedImage().getImage().getArray()
         self.im2 = self.science.getMaskedImage().getImage().getArray()
         self.im1_var = self.template.getMaskedImage().getVariance().getArray()
         self.im2_var = self.science.getMaskedImage().getVariance().getArray()
  
         def selectPsf(psf, exposure):
             if psf is not None:
                 return psf
             else:
                 bbox1 = self.template.getBBox()
                 xcen = (bbox1.getBeginX() + bbox1.getEndX()) / 2.
                 ycen = (bbox1.getBeginY() + bbox1.getEndY()) / 2.
                 return exposure.getPsf().computeKernelImage(geom.Point2D(xcen, ycen)).getArray()
  
         self.im1_psf = selectPsf(psf1, self.template)
         self.im2_psf = selectPsf(psf2, self.science)
  
         # Make sure PSFs are the same size. Messy, but should work for all cases.
         psf1 = self.im1_psf
         psf2 = self.im2_psf
         pShape1 = psf1.shape
         pShape2 = psf2.shape
         if (pShape1[0] < pShape2[0]):
             psf1 = np.pad(psf1, ((0, pShape2[0] - pShape1[0]), (0, 0)), mode='constant', constant_values=0.)
         elif (pShape2[0] < pShape1[0]):
             psf2 = np.pad(psf2, ((0, pShape1[0] - pShape2[0]), (0, 0)), mode='constant', constant_values=0.)
         if (pShape1[1] < pShape2[1]):
             psf1 = np.pad(psf1, ((0, 0), (0, pShape2[1] - pShape1[1])), mode='constant', constant_values=0.)
         elif (pShape2[1] < pShape1[1]):
             psf2 = np.pad(psf2, ((0, 0), (0, pShape1[1] - pShape2[1])), mode='constant', constant_values=0.)
  
         # PSFs' centers may be offset relative to each other; now fix that!
         maxLoc1 = np.unravel_index(np.argmax(psf1), psf1.shape)
         maxLoc2 = np.unravel_index(np.argmax(psf2), psf2.shape)
         # *Very* rarely happens but if they're off by >1 pixel, do it more than once.
         while (maxLoc1[0] != maxLoc2[0]) or (maxLoc1[1] != maxLoc2[1]):
             if maxLoc1[0] > maxLoc2[0]:
                 psf2[1:, :] = psf2[:-1, :]
             elif maxLoc1[0] < maxLoc2[0]:
                 psf1[1:, :] = psf1[:-1, :]
             if maxLoc1[1] > maxLoc2[1]:
                 psf2[:, 1:] = psf2[:, :-1]
             elif maxLoc1[1] < maxLoc2[1]:
                 psf1[:, 1:] = psf1[:, :-1]
             maxLoc1 = np.unravel_index(np.argmax(psf1), psf1.shape)
             maxLoc2 = np.unravel_index(np.argmax(psf2), psf2.shape)
  
         # Make sure there are no div-by-zeros
         psf1[psf1 < MIN_KERNEL] = MIN_KERNEL
         psf2[psf2 < MIN_KERNEL] = MIN_KERNEL
  
         self.im1_psf = psf1
         self.im2_psf = psf2
  
         self.sig1 = np.sqrt(self._computeVarianceMean(self.template)) if sig1 is None else sig1
         self.sig2 = np.sqrt(self._computeVarianceMean(self.science)) if sig2 is None else sig2
         # if sig1 or sig2 are NaN, then the entire region being Zogy-ed is masked.
         # Don't worry about it - the result will be masked but avoid warning messages.
         if np.isnan(self.sig1) or self.sig1 == 0:
             self.sig1 = 1.
         if np.isnan(self.sig2) or self.sig2 == 0:
             self.sig2 = 1.
  
         # Zogy doesn't correct nonzero backgrounds (unlike AL) so subtract them here.
         if correctBackground:
             def _subtractImageMean(exposure):
                 """Compute the sigma-clipped mean of the image of `exposure`."""
                 mi = exposure.getMaskedImage()
                 statObj = afwMath.makeStatistics(mi.getImage(), mi.getMask(),
                                                  afwMath.MEANCLIP, self.statsControl)
                 mean = statObj.getValue(afwMath.MEANCLIP)
                 if not np.isnan(mean):
                     mi -= mean
  
             _subtractImageMean(self.template)
             _subtractImageMean(self.science)
  
         # Define the normalization of each image from the config
         self.Fr = self.config.templateFluxScaling  # default is 1
         self.Fn = self.config.scienceFluxScaling  # default is 1
         # If 'scaleByCalibration' is True then these norms are overwritten
         if self.config.scaleByCalibration:
             calib_template = self.template.getPhotoCalib()
             calib_science = self.science.getPhotoCalib()
             if calib_template is None:
                 self.log.warning("No calibration information available for template image.")
             if calib_science is None:
                 self.log.warning("No calibration information available for science image.")
             if calib_template is None or calib_science is None:
                 self.log.warning("Due to lack of calibration information, "
                                  "reverting to templateFluxScaling and scienceFluxScaling.")
             else:
                 self.Fr = 1/calib_template.getCalibrationMean()
                 self.Fn = 1/calib_science.getCalibrationMean()
  
         self.log.info("Setting template image scaling to Fr=%f" % self.Fr)
         self.log.info("Setting science  image scaling to Fn=%f" % self.Fn)
  
         self.padSize = self.config.padSize  # default is 7
  

Member Data Documentation

◆ ConfigClass

lsst.ip.diffim.zogy.ZogyMapper.ConfigClass = ZogyConfig

static

Definition at line 931 of file zogy.py.

◆ Fn

lsst.ip.diffim.zogy.ZogyTask.Fn

inherited

Definition at line 301 of file zogy.py.

◆ Fr

lsst.ip.diffim.zogy.ZogyTask.Fr

inherited

Definition at line 300 of file zogy.py.

◆ im1

lsst.ip.diffim.zogy.ZogyTask.im1

inherited

Definition at line 222 of file zogy.py.

◆ im1_psf

lsst.ip.diffim.zogy.ZogyTask.im1_psf

inherited

Definition at line 236 of file zogy.py.

◆ im1_var

lsst.ip.diffim.zogy.ZogyTask.im1_var

inherited

Definition at line 224 of file zogy.py.

◆ im2

lsst.ip.diffim.zogy.ZogyTask.im2

inherited

Definition at line 223 of file zogy.py.

◆ im2_psf

lsst.ip.diffim.zogy.ZogyTask.im2_psf

inherited

Definition at line 237 of file zogy.py.

◆ im2_var

lsst.ip.diffim.zogy.ZogyTask.im2_var

inherited

Definition at line 225 of file zogy.py.

◆ padSize

lsst.ip.diffim.zogy.ZogyTask.padSize

inherited

Definition at line 320 of file zogy.py.

◆ science

lsst.ip.diffim.zogy.ZogyTask.science

inherited

Definition at line 171 of file zogy.py.

◆ sig1

lsst.ip.diffim.zogy.ZogyTask.sig1

inherited

Definition at line 276 of file zogy.py.

◆ sig2

lsst.ip.diffim.zogy.ZogyTask.sig2

inherited

Definition at line 277 of file zogy.py.

◆ statsControl

lsst.ip.diffim.zogy.ZogyTask.statsControl

inherited

Definition at line 216 of file zogy.py.

◆ template

lsst.ip.diffim.zogy.ZogyTask.template

inherited

Definition at line 171 of file zogy.py.

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

/j/snowflake/release/lsstsw/stack/1a1d771/Linux64/ip_diffim/20.0.0-1-g596936a+28/python/lsst/ip/diffim/zogy.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ computeDiffim()

◆ computeDiffimFourierSpace()

◆ computeDiffimImageSpace()

◆ computeDiffimPsf()

◆ computePrereqs()

◆ computeScorr()

◆ computeScorrFourierSpace()

◆ computeScorrImageSpace()

◆ run() [1/2]

◆ run() [2/2]

◆ setup()

Member Data Documentation

◆ ConfigClass

◆ Fn

◆ Fr

◆ im1

◆ im1_psf

◆ im1_var

◆ im2

◆ im2_psf

◆ im2_var

◆ padSize

◆ science

◆ sig1

◆ sig2

◆ statsControl

◆ template

◆ init()