lsst.ip.isr.fringe.FringeTask Class Reference

Inheritance diagram for lsst.ip.isr.fringe.FringeTask:

Public Member Functions
def	readFringes (self, dataRef, expId=None, assembler=None)
def	loadFringes (self, fringeExp, expId=None, assembler=None)
def	run (self, exposure, fringes, seed=None)
def	runDataRef (self, exposure, dataRef, assembler=None)
def	checkFilter (self, exposure)
def	removePedestal (self, fringe)
def	generatePositions (self, exposure, rng)
def	measureExposure (self, exposure, positions, title="Fringe")
def	solve (self, science, fringes)
def	subtract (self, science, fringes, solution)

Static Public Attributes
	ConfigClass = FringeConfig

Detailed Description

Task to remove fringes from a science exposure

We measure fringe amplitudes at random positions on the science exposure
and at the same positions on the (potentially multiple) fringe frames
and solve for the scales simultaneously.

Definition at line 73 of file fringe.py.

Member Function Documentation

checkFilter()

def lsst.ip.isr.fringe.FringeTask.checkFilter	(		self,
			exposure
	)

Check whether we should fringe-subtract the science exposure.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to check the filter of.

Returns
-------
needsFringe : `bool`
    If True, then the exposure has a filter listed in the
    configuration, and should have the fringe applied.

Definition at line 246 of file fringe.py.

    def checkFilter(self, exposure):
        """Check whether we should fringe-subtract the science exposure.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to check the filter of.
 
        Returns
        -------
        needsFringe : `bool`
            If True, then the exposure has a filter listed in the
            configuration, and should have the fringe applied.
        """
        return checkFilter(exposure, self.config.filters, log=self.log)
 

generatePositions()

def lsst.ip.isr.fringe.FringeTask.generatePositions	(		self,
			exposure,
			rng
	)

Generate a random distribution of positions for measuring fringe amplitudes.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to measure the positions on.
rng : `numpy.random.RandomState`
    Random number generator to use.

Returns
-------
positions : `numpy.array`
    Two-dimensional array containing the positions to sample
    for fringe amplitudes.

Definition at line 278 of file fringe.py.

    def generatePositions(self, exposure, rng):
        """Generate a random distribution of positions for measuring fringe amplitudes.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to measure the positions on.
        rng : `numpy.random.RandomState`
            Random number generator to use.
 
        Returns
        -------
        positions : `numpy.array`
            Two-dimensional array containing the positions to sample
            for fringe amplitudes.
        """
        start = self.config.large
        num = self.config.num
        width = exposure.getWidth() - self.config.large
        height = exposure.getHeight() - self.config.large
        return numpy.array([rng.randint(start, width, size=num),
                            rng.randint(start, height, size=num)]).swapaxes(0, 1)
 

loadFringes()

def lsst.ip.isr.fringe.FringeTask.loadFringes	(		self,
			fringeExp,
			expId = None,
			assembler = None
	)

Pack the fringe data into a Struct.

This method moves the struct parsing code into a butler
generation agnostic handler.

Parameters
----------
fringeExp : `lsst.afw.exposure.Exposure`
    The exposure containing the fringe data.
expId : `int`, optional
    Exposure id to be fringe corrected, used to set RNG seed.
assembler : `lsst.ip.isr.AssembleCcdTask`, optional
    An instance of AssembleCcdTask (for assembling fringe
    frames).

Returns
-------
fringeData : `pipeBase.Struct`
    Struct containing fringe data:
    - ``fringes`` : `lsst.afw.image.Exposure` or `list` thereof
        Calibration fringe files containing master fringe frames.
    - ``seed`` : `int`, optional
        Seed for random number generation.

Definition at line 119 of file fringe.py.

    def loadFringes(self, fringeExp, expId=None, assembler=None):
        """Pack the fringe data into a Struct.
 
        This method moves the struct parsing code into a butler
        generation agnostic handler.
 
        Parameters
        ----------
        fringeExp : `lsst.afw.exposure.Exposure`
            The exposure containing the fringe data.
        expId : `int`, optional
            Exposure id to be fringe corrected, used to set RNG seed.
        assembler : `lsst.ip.isr.AssembleCcdTask`, optional
            An instance of AssembleCcdTask (for assembling fringe
            frames).
 
        Returns
        -------
        fringeData : `pipeBase.Struct`
            Struct containing fringe data:
            - ``fringes`` : `lsst.afw.image.Exposure` or `list` thereof
                Calibration fringe files containing master fringe frames.
            - ``seed`` : `int`, optional
                Seed for random number generation.
        """
        if assembler is not None:
            fringeExp = assembler.assembleCcd(fringeExp)
 
        if expId is None:
            seed = self.config.stats.rngSeedOffset
        else:
            print(f"{self.config.stats.rngSeedOffset} {expId}")
            seed = self.config.stats.rngSeedOffset + expId
 
        # Seed for numpy.random.RandomState must be convertable to a 32 bit unsigned integer
        seed %= 2**32
 
        return Struct(fringes=fringeExp,
                      seed=seed)
 

measureExposure()

def lsst.ip.isr.fringe.FringeTask.measureExposure	(		self,
			exposure,
			positions,
			title = "Fringe"
	)

Measure fringe amplitudes for an exposure

The fringe amplitudes are measured as the statistic within a square
aperture.  The statistic within a larger aperture are subtracted so
as to remove the background.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Exposure to measure the positions on.
positions : `numpy.array`
    Two-dimensional array containing the positions to sample
    for fringe amplitudes.
title : `str`, optional
    Title used for debug out plots.

Returns
-------
fringes : `numpy.array`
    Array of measured exposure values at each of the positions
    supplied.

Definition at line 302 of file fringe.py.

    def measureExposure(self, exposure, positions, title="Fringe"):
        """Measure fringe amplitudes for an exposure
 
        The fringe amplitudes are measured as the statistic within a square
        aperture.  The statistic within a larger aperture are subtracted so
        as to remove the background.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Exposure to measure the positions on.
        positions : `numpy.array`
            Two-dimensional array containing the positions to sample
            for fringe amplitudes.
        title : `str`, optional
            Title used for debug out plots.
 
        Returns
        -------
        fringes : `numpy.array`
            Array of measured exposure values at each of the positions
            supplied.
        """
        stats = afwMath.StatisticsControl()
        stats.setNumSigmaClip(self.config.stats.clip)
        stats.setNumIter(self.config.stats.iterations)
        stats.setAndMask(exposure.getMaskedImage().getMask().getPlaneBitMask(self.config.stats.badMaskPlanes))
 
        num = self.config.num
        fringes = numpy.ndarray(num)
 
        for i in range(num):
            x, y = positions[i]
            small = measure(exposure.getMaskedImage(), x, y, self.config.small, self.config.stats.stat, stats)
            large = measure(exposure.getMaskedImage(), x, y, self.config.large, self.config.stats.stat, stats)
            fringes[i] = small - large
 
        import lsstDebug
        display = lsstDebug.Info(__name__).display
        if display:
            disp = afwDisplay.Display(frame=getFrame())
            disp.mtv(exposure, title=title)
            if False:
                with disp.Buffering():
                    for x, y in positions:
                        corners = numpy.array([[-1, -1], [1, -1], [1, 1], [-1, 1], [-1, -1]]) + [[x, y]]
                        disp.line(corners*self.config.small, ctype=afwDisplay.GREEN)
                        disp.line(corners*self.config.large, ctype=afwDisplay.BLUE)
 
        return fringes
 

readFringes()

def lsst.ip.isr.fringe.FringeTask.readFringes	(		self,
			dataRef,
			expId = None,
			assembler = None
	)

Read the fringe frame(s), and pack data into a Struct

The current implementation assumes only a single fringe frame and
will have to be updated to support multi-mode fringe subtraction.

This implementation could be optimised by persisting the fringe
positions and fluxes.

Parameters
----------
dataRef : `daf.butler.butlerSubset.ButlerDataRef`
    Butler reference for the exposure that will have fringing
    removed.
expId : `int`, optional
    Exposure id to be fringe corrected, used to set RNG seed.
assembler : `lsst.ip.isr.AssembleCcdTask`, optional
    An instance of AssembleCcdTask (for assembling fringe
    frames).

Returns
-------
fringeData : `pipeBase.Struct`
    Struct containing fringe data:
    - ``fringes`` : `lsst.afw.image.Exposure` or `list` thereof
        Calibration fringe files containing master fringe frames.
    - ``seed`` : `int`, optional
        Seed for random number generation.

Definition at line 83 of file fringe.py.

    def readFringes(self, dataRef, expId=None, assembler=None):
        """Read the fringe frame(s), and pack data into a Struct
 
        The current implementation assumes only a single fringe frame and
        will have to be updated to support multi-mode fringe subtraction.
 
        This implementation could be optimised by persisting the fringe
        positions and fluxes.
 
        Parameters
        ----------
        dataRef : `daf.butler.butlerSubset.ButlerDataRef`
            Butler reference for the exposure that will have fringing
            removed.
        expId : `int`, optional
            Exposure id to be fringe corrected, used to set RNG seed.
        assembler : `lsst.ip.isr.AssembleCcdTask`, optional
            An instance of AssembleCcdTask (for assembling fringe
            frames).
 
        Returns
        -------
        fringeData : `pipeBase.Struct`
            Struct containing fringe data:
            - ``fringes`` : `lsst.afw.image.Exposure` or `list` thereof
                Calibration fringe files containing master fringe frames.
            - ``seed`` : `int`, optional
                Seed for random number generation.
        """
        try:
            fringe = dataRef.get("fringe", immediate=True)
        except Exception as e:
            raise RuntimeError("Unable to retrieve fringe for %s: %s" % (dataRef.dataId, e))
 
        return self.loadFringes(fringe, expId=expId, assembler=assembler)
 

removePedestal()

def lsst.ip.isr.fringe.FringeTask.removePedestal	(		self,
			fringe
	)

Remove pedestal from fringe exposure.

Parameters
----------
fringe : `lsst.afw.image.Exposure`
    Fringe data to subtract the pedestal value from.

Definition at line 262 of file fringe.py.

    def removePedestal(self, fringe):
        """Remove pedestal from fringe exposure.
 
        Parameters
        ----------
        fringe : `lsst.afw.image.Exposure`
            Fringe data to subtract the pedestal value from.
        """
        stats = afwMath.StatisticsControl()
        stats.setNumSigmaClip(self.config.stats.clip)
        stats.setNumIter(self.config.stats.iterations)
        mi = fringe.getMaskedImage()
        pedestal = afwMath.makeStatistics(mi, afwMath.MEDIAN, stats).getValue()
        self.log.info("Removing fringe pedestal: %f", pedestal)
        mi -= pedestal
 

run()

def lsst.ip.isr.fringe.FringeTask.run	(		self,
			exposure,
			fringes,
			seed = None
	)

Remove fringes from the provided science exposure.

Primary method of FringeTask.  Fringes are only subtracted if the
science exposure has a filter listed in the configuration.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Science exposure from which to remove fringes.
fringes : `lsst.afw.image.Exposure` or `list` thereof
    Calibration fringe files containing master fringe frames.
seed : `int`, optional
    Seed for random number generation.

Returns
-------
solution : `np.array`
    Fringe solution amplitudes for each input fringe frame.
rms : `float`
    RMS error for the fit solution for this exposure.

Definition at line 160 of file fringe.py.

    def run(self, exposure, fringes, seed=None):
        """Remove fringes from the provided science exposure.
 
        Primary method of FringeTask.  Fringes are only subtracted if the
        science exposure has a filter listed in the configuration.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Science exposure from which to remove fringes.
        fringes : `lsst.afw.image.Exposure` or `list` thereof
            Calibration fringe files containing master fringe frames.
        seed : `int`, optional
            Seed for random number generation.
 
        Returns
        -------
        solution : `np.array`
            Fringe solution amplitudes for each input fringe frame.
        rms : `float`
            RMS error for the fit solution for this exposure.
        """
        import lsstDebug
        display = lsstDebug.Info(__name__).display
 
        if not self.checkFilter(exposure):
            self.log.info("Filter not found in FringeTaskConfig.filters. Skipping fringe correction.")
            return
 
        if seed is None:
            seed = self.config.stats.rngSeedOffset
        rng = numpy.random.RandomState(seed=seed)
 
        if not hasattr(fringes, '__iter__'):
            fringes = [fringes]
 
        mask = exposure.getMaskedImage().getMask()
        for fringe in fringes:
            fringe.getMaskedImage().getMask().__ior__(mask)
            if self.config.pedestal:
                self.removePedestal(fringe)
 
        positions = self.generatePositions(fringes[0], rng)
        fluxes = numpy.ndarray([self.config.num, len(fringes)])
        for i, f in enumerate(fringes):
            fluxes[:, i] = self.measureExposure(f, positions, title="Fringe frame")
 
        expFringes = self.measureExposure(exposure, positions, title="Science")
        solution, rms = self.solve(expFringes, fluxes)
        self.subtract(exposure, fringes, solution)
        if display:
            afwDisplay.Display(frame=getFrame()).mtv(exposure, title="Fringe subtracted")
        return solution, rms
 

runDataRef()

def lsst.ip.isr.fringe.FringeTask.runDataRef	(		self,
			exposure,
			dataRef,
			assembler = None
	)

Remove fringes from the provided science exposure.

Retrieve fringes from butler dataRef provided and remove from
provided science exposure. Fringes are only subtracted if the
science exposure has a filter listed in the configuration.

Parameters
----------
exposure : `lsst.afw.image.Exposure`
    Science exposure from which to remove fringes.
dataRef : `daf.persistence.butlerSubset.ButlerDataRef`
    Butler reference to the exposure.  Used to find
    appropriate fringe data.
assembler : `lsst.ip.isr.AssembleCcdTask`, optional
    An instance of AssembleCcdTask (for assembling fringe
    frames).

Returns
-------
solution : `np.array`
    Fringe solution amplitudes for each input fringe frame.
rms : `float`
    RMS error for the fit solution for this exposure.

Definition at line 215 of file fringe.py.

    def runDataRef(self, exposure, dataRef, assembler=None):
        """Remove fringes from the provided science exposure.
 
        Retrieve fringes from butler dataRef provided and remove from
        provided science exposure. Fringes are only subtracted if the
        science exposure has a filter listed in the configuration.
 
        Parameters
        ----------
        exposure : `lsst.afw.image.Exposure`
            Science exposure from which to remove fringes.
        dataRef : `daf.persistence.butlerSubset.ButlerDataRef`
            Butler reference to the exposure.  Used to find
            appropriate fringe data.
        assembler : `lsst.ip.isr.AssembleCcdTask`, optional
            An instance of AssembleCcdTask (for assembling fringe
            frames).
 
        Returns
        -------
        solution : `np.array`
            Fringe solution amplitudes for each input fringe frame.
        rms : `float`
            RMS error for the fit solution for this exposure.
        """
        if not self.checkFilter(exposure):
            self.log.info("Filter not found in FringeTaskConfig.filters. Skipping fringe correction.")
            return
        fringeStruct = self.readFringes(dataRef, assembler=assembler)
        return self.run(exposure, **fringeStruct.getDict())
 

solve()

def lsst.ip.isr.fringe.FringeTask.solve	(		self,
			science,
			fringes
	)

Solve for the scale factors with iterative clipping.

Parameters
----------
science : `numpy.array`
    Array of measured science image values at each of the
    positions supplied.
fringes : `numpy.array`
    Array of measured fringe values at each of the positions
    supplied.

Returns
-------
solution : `np.array`
    Fringe solution amplitudes for each input fringe frame.
rms : `float`
    RMS error for the fit solution for this exposure.

Definition at line 354 of file fringe.py.

    def solve(self, science, fringes):
        """Solve for the scale factors with iterative clipping.
 
        Parameters
        ----------
        science : `numpy.array`
            Array of measured science image values at each of the
            positions supplied.
        fringes : `numpy.array`
            Array of measured fringe values at each of the positions
            supplied.
 
        Returns
        -------
        solution : `np.array`
            Fringe solution amplitudes for each input fringe frame.
        rms : `float`
            RMS error for the fit solution for this exposure.
        """
        import lsstDebug
        doPlot = lsstDebug.Info(__name__).plot
 
        origNum = len(science)
 
        def emptyResult(msg=""):
            """Generate an empty result for return to the user
 
            There are no good pixels; doesn't matter what we return.
            """
            self.log.warning("Unable to solve for fringes: no good pixels%s", msg)
            out = [0]
            if len(fringes) > 1:
                out = out*len(fringes)
            return numpy.array(out), numpy.nan
 
        good = numpy.where(numpy.logical_and(numpy.isfinite(science), numpy.any(numpy.isfinite(fringes), 1)))
        science = science[good]
        fringes = fringes[good]
        oldNum = len(science)
        if oldNum == 0:
            return emptyResult()
 
        # Up-front rejection to get rid of extreme, potentially troublesome values
        # (e.g., fringe apertures that fall on objects).
        good = select(science, self.config.clip)
        for ff in range(fringes.shape[1]):
            good &= select(fringes[:, ff], self.config.clip)
        science = science[good]
        fringes = fringes[good]
        oldNum = len(science)
        if oldNum == 0:
            return emptyResult(" after initial rejection")
 
        for i in range(self.config.iterations):
            solution = self._solve(science, fringes)
            resid = science - numpy.sum(solution*fringes, 1)
            rms = stdev(resid)
            good = numpy.logical_not(abs(resid) > self.config.clip*rms)
            self.log.debug("Iteration %d: RMS=%f numGood=%d", i, rms, good.sum())
            self.log.debug("Solution %d: %s", i, solution)
            newNum = good.sum()
            if newNum == 0:
                return emptyResult(" after %d rejection iterations" % i)
 
            if doPlot:
                import matplotlib.pyplot as plot
                for j in range(fringes.shape[1]):
                    fig = plot.figure(j)
                    fig.clf()
                    try:
                        fig.canvas._tkcanvas._root().lift()  # == Tk's raise
                    except Exception:
                        pass
                    ax = fig.add_subplot(1, 1, 1)
                    adjust = science.copy()
                    others = set(range(fringes.shape[1]))
                    others.discard(j)
                    for k in others:
                        adjust -= solution[k]*fringes[:, k]
                    ax.plot(fringes[:, j], adjust, 'r.')
                    xmin = fringes[:, j].min()
                    xmax = fringes[:, j].max()
                    ymin = solution[j]*xmin
                    ymax = solution[j]*xmax
                    ax.plot([xmin, xmax], [ymin, ymax], 'b-')
                    ax.set_title("Fringe %d: %f" % (j, solution[j]))
                    ax.set_xlabel("Fringe amplitude")
                    ax.set_ylabel("Science amplitude")
                    ax.set_autoscale_on(False)
                    ax.set_xbound(lower=xmin, upper=xmax)
                    ax.set_ybound(lower=ymin, upper=ymax)
                    fig.show()
                while True:
                    ans = input("Enter or c to continue [chp]").lower()
                    if ans in ("", "c",):
                        break
                    if ans in ("p",):
                        import pdb
                        pdb.set_trace()
                    elif ans in ("h", ):
                        print("h[elp] c[ontinue] p[db]")
 
            if newNum == oldNum:
                # Not gaining
                break
            oldNum = newNum
            good = numpy.where(good)
            science = science[good]
            fringes = fringes[good]
 
        # Final solution without rejection
        solution = self._solve(science, fringes)
        self.log.info("Fringe solution: %s RMS: %f Good: %d/%d", solution, rms, len(science), origNum)
        return solution, rms
 

subtract()

def lsst.ip.isr.fringe.FringeTask.subtract	(		self,
			science,
			fringes,
			solution
	)

Subtract the fringes.

Parameters
----------
science : `lsst.afw.image.Exposure`
    Science exposure from which to remove fringes.
fringes : `lsst.afw.image.Exposure` or `list` thereof
    Calibration fringe files containing master fringe frames.
solution : `np.array`
    Fringe solution amplitudes for each input fringe frame.

Raises
------
RuntimeError :
    Raised if the number of fringe frames does not match the
    number of measured amplitudes.

Definition at line 489 of file fringe.py.

    def subtract(self, science, fringes, solution):
        """Subtract the fringes.
 
        Parameters
        ----------
        science : `lsst.afw.image.Exposure`
            Science exposure from which to remove fringes.
        fringes : `lsst.afw.image.Exposure` or `list` thereof
            Calibration fringe files containing master fringe frames.
        solution : `np.array`
            Fringe solution amplitudes for each input fringe frame.
 
        Raises
        ------
        RuntimeError :
            Raised if the number of fringe frames does not match the
            number of measured amplitudes.
        """
        if len(solution) != len(fringes):
            raise RuntimeError("Number of fringe frames (%s) != number of scale factors (%s)" %
                               (len(fringes), len(solution)))
 
        for s, f in zip(solution, fringes):
            # We do not want to add the mask from the fringe to the image.
            f.getMaskedImage().getMask().getArray()[:] = 0
            science.getMaskedImage().scaledMinus(s, f.getMaskedImage())
 
 

Member Data Documentation

ConfigClass

lsst.ip.isr.fringe.FringeTask.ConfigClass = FringeConfig

static

Definition at line 80 of file fringe.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ip_isr/22.0.1-27-g97737f7+2a20fdde0d/python/lsst/ip/isr/fringe.py