Public Member Functions
	__init__ (self, data, weights, line=None)

	setLineMask (self, line)

	makeProfile (self, line, fitFlux=True)

	fit (self, dChi2Tol=0.1, maxIter=100, log=None)

Public Attributes
	data

	weights

	mask

	lineMask

	lineMaskSize

Protected Member Functions
	_makeMaskedProfile (self, line, fitFlux=True)

	_lineChi2 (self, line, grad=True)

Protected Attributes
	_ymax

	_xmax

	_dtype

	_rhoMax

	_xmesh

	_ymesh

	_initLine

	_maskData

	_maskWeights

	_mxmesh

	_mymesh

Detailed Description

Construct and/or fit a model for a linear streak.

This assumes a simple model for a streak, in which the streak
follows a straight line in pixels space, with a Moffat-shaped profile. The
model is fit to data using a Newton-Raphson style minimization algorithm.
The initial guess for the line parameters is assumed to be fairly accurate,
so only a narrow band of pixels around the initial line estimate is used in
fitting the model, which provides a significant speed-up over using all the
data. The class can also be used just to construct a model for the data with
a line following the given coordinates.

Parameters
----------
data : `np.ndarray`
    2d array of data.
weights : `np.ndarray`
    2d array of weights.
line : `Line`, optional
    Guess for position of line. Data far from line guess is masked out.
    Defaults to None, in which case only data with `weights` = 0 is masked
    out.

Definition at line 189 of file maskStreaks.py.

Constructor & Destructor Documentation

◆ init()

lsst.pipe.tasks.maskStreaks.LineProfile.__init__	(	self,
		data,
		weights,
		line = None )

Definition at line 213 of file maskStreaks.py.

    def __init__(self, data, weights, line=None):
        self.data = data
        self.weights = weights
        self._ymax, self._xmax = data.shape
        self._dtype = data.dtype
        xrange = np.arange(self._xmax) - self._xmax / 2.
        yrange = np.arange(self._ymax) - self._ymax / 2.
        self._rhoMax = ((0.5 * self._ymax)**2 + (0.5 * self._xmax)**2)**0.5
        self._xmesh, self._ymesh = np.meshgrid(xrange, yrange)
        self.mask = (weights != 0)
 
        self._initLine = line
        self.setLineMask(line)
 

Member Function Documentation

◆ _lineChi2()

lsst.pipe.tasks.maskStreaks.LineProfile._lineChi2	(	self,
		line,
		grad = True )

protected

Construct the chi2 between the data and the model.

Parameters
----------
line : `Line`
    `Line` parameters for which to build model and calculate chi2.
grad : `bool`, optional
    Whether or not to return the gradient and hessian.

Returns
-------
reducedChi : `float`
    Reduced chi2 of the model.
reducedDChi : `np.ndarray`
    Derivative of the chi2 with respect to rho, theta, invSigma.
reducedHessianChi : `np.ndarray`
    Hessian of the chi2 with respect to rho, theta, invSigma.

Definition at line 328 of file maskStreaks.py.

    def _lineChi2(self, line, grad=True):
        """Construct the chi2 between the data and the model.
 
        Parameters
        ----------
        line : `Line`
            `Line` parameters for which to build model and calculate chi2.
        grad : `bool`, optional
            Whether or not to return the gradient and hessian.
 
        Returns
        -------
        reducedChi : `float`
            Reduced chi2 of the model.
        reducedDChi : `np.ndarray`
            Derivative of the chi2 with respect to rho, theta, invSigma.
        reducedHessianChi : `np.ndarray`
            Hessian of the chi2 with respect to rho, theta, invSigma.
        """
        # Calculate chi2
        model, dModel = self._makeMaskedProfile(line)
        chi2 = (self._maskWeights * (self._maskData - model)**2).sum()
        if not grad:
            return chi2.sum() / self.lineMaskSize
 
        # Calculate derivative and Hessian of chi2
        derivChi2 = ((-2 * self._maskWeights * (self._maskData - model))[None, :] * dModel).sum(axis=1)
        hessianChi2 = (2 * self._maskWeights * dModel[:, None, :] * dModel[None, :, :]).sum(axis=2)
 
        reducedChi = chi2 / self.lineMaskSize
        reducedDChi = derivChi2 / self.lineMaskSize
        reducedHessianChi = hessianChi2 / self.lineMaskSize
        return reducedChi, reducedDChi, reducedHessianChi
 

◆ _makeMaskedProfile()

lsst.pipe.tasks.maskStreaks.LineProfile._makeMaskedProfile	(	self,
		line,
		fitFlux = True )

protected

Construct the line model in the masked region and calculate its
derivatives.

Parameters
----------
line : `Line`
    Parameters of line profile for which to make profile in the masked
    region.
fitFlux : `bool`
    Fit the amplitude of the line profile to the data.

Returns
-------
model : `np.ndarray`
    Model in the masked region.
dModel : `np.ndarray`
    Derivative of the model in the masked region.

Definition at line 250 of file maskStreaks.py.

    def _makeMaskedProfile(self, line, fitFlux=True):
        """Construct the line model in the masked region and calculate its
        derivatives.
 
        Parameters
        ----------
        line : `Line`
            Parameters of line profile for which to make profile in the masked
            region.
        fitFlux : `bool`
            Fit the amplitude of the line profile to the data.
 
        Returns
        -------
        model : `np.ndarray`
            Model in the masked region.
        dModel : `np.ndarray`
            Derivative of the model in the masked region.
        """
        invSigma = line.sigma**-1
        # Calculate distance between pixels and line
        radtheta = np.deg2rad(line.theta)
        costheta = np.cos(radtheta)
        sintheta = np.sin(radtheta)
        distance = (costheta * self._mxmesh + sintheta * self._mymesh - line.rho)
        distanceSquared = distance**2
 
        # Calculate partial derivatives of distance
        drad = np.pi / 180
        dDistanceSqdRho = 2 * distance * (-np.ones_like(self._mxmesh))
        dDistanceSqdTheta = (2 * distance * (-sintheta * self._mxmesh + costheta * self._mymesh) * drad)
 
        # Use pixel-line distances to make Moffat profile
        profile = (1 + distanceSquared * invSigma**2)**-2.5
        dProfile = -2.5 * (1 + distanceSquared * invSigma**2)**-3.5
 
        if fitFlux:
            # Calculate line flux from profile and data
            flux = ((self._maskWeights * self._maskData * profile).sum()
                    / (self._maskWeights * profile**2).sum())
        else:
            # Approximately normalize the line
            flux = invSigma**-1
        if np.isnan(flux):
            flux = 0
 
        model = flux * profile
 
        # Calculate model derivatives
        fluxdProfile = flux * dProfile
        fluxdProfileInvSigma = fluxdProfile * invSigma**2
        dModeldRho = fluxdProfileInvSigma * dDistanceSqdRho
        dModeldTheta = fluxdProfileInvSigma * dDistanceSqdTheta
        dModeldInvSigma = fluxdProfile * distanceSquared * 2 * invSigma
 
        dModel = np.array([dModeldRho, dModeldTheta, dModeldInvSigma])
        return model, dModel
 

◆ fit()

lsst.pipe.tasks.maskStreaks.LineProfile.fit	(	self,
		dChi2Tol = 0.1,
		maxIter = 100,
		log = None )

Perform Newton-Raphson minimization to find line parameters.

This method takes advantage of having known derivative and Hessian of
the multivariate function to quickly and efficiently find the minimum.
This is more efficient than the scipy implementation of the Newton-
Raphson method, which doesn't take advantage of the Hessian matrix. The
method here also performs a line search in the direction of the steepest
derivative at each iteration, which reduces the number of iterations
needed.

Parameters
----------
dChi2Tol : `float`, optional
    Change in Chi2 tolerated for fit convergence.
maxIter : `int`, optional
    Maximum number of fit iterations allowed. The fit should converge in
    ~10 iterations, depending on the value of dChi2Tol, but this
    maximum provides a backup.
log : `lsst.utils.logging.LsstLogAdapter`, optional
    Logger to use for reporting more details for fitting failures.

Returns
-------
outline : `np.ndarray`
    Coordinates and inverse width of fit line.
chi2 : `float`
    Reduced Chi2 of model fit to data.
fitFailure : `bool`
    Boolean where `False` corresponds to a successful  fit.

Definition at line 362 of file maskStreaks.py.

    def fit(self, dChi2Tol=0.1, maxIter=100, log=None):
        """Perform Newton-Raphson minimization to find line parameters.
 
        This method takes advantage of having known derivative and Hessian of
        the multivariate function to quickly and efficiently find the minimum.
        This is more efficient than the scipy implementation of the Newton-
        Raphson method, which doesn't take advantage of the Hessian matrix. The
        method here also performs a line search in the direction of the steepest
        derivative at each iteration, which reduces the number of iterations
        needed.
 
        Parameters
        ----------
        dChi2Tol : `float`, optional
            Change in Chi2 tolerated for fit convergence.
        maxIter : `int`, optional
            Maximum number of fit iterations allowed. The fit should converge in
            ~10 iterations, depending on the value of dChi2Tol, but this
            maximum provides a backup.
        log : `lsst.utils.logging.LsstLogAdapter`, optional
            Logger to use for reporting more details for fitting failures.
 
        Returns
        -------
        outline : `np.ndarray`
            Coordinates and inverse width of fit line.
        chi2 : `float`
            Reduced Chi2 of model fit to data.
        fitFailure : `bool`
            Boolean where `False` corresponds to a successful  fit.
        """
        # Do minimization on inverse of sigma to simplify derivatives:
        x = np.array([self._initLine.rho, self._initLine.theta, self._initLine.sigma**-1])
 
        dChi2 = 1
        iter = 0
        oldChi2 = 0
        fitFailure = False
 
        def line_search(c, dx):
            testx = x - c * dx
            testLine = Line(testx[0], testx[1], testx[2]**-1)
            return self._lineChi2(testLine, grad=False)
 
        while abs(dChi2) > dChi2Tol:
            line = Line(x[0], x[1], x[2]**-1)
            chi2, b, A = self._lineChi2(line)
            if chi2 == 0:
                break
            if not np.isfinite(A).all():
                fitFailure = True
                if log is not None:
                    log.warning("Hessian matrix has non-finite elements.")
                break
            dChi2 = oldChi2 - chi2
            try:
                cholesky = scipy.linalg.cho_factor(A)
            except np.linalg.LinAlgError:
                fitFailure = True
                if log is not None:
                    log.warning("Hessian matrix is not invertible.")
                break
            dx = scipy.linalg.cho_solve(cholesky, b)
 
            factor, fmin, _, _ = scipy.optimize.brent(line_search, args=(dx,), full_output=True, tol=0.05)
            x -= factor * dx
            if (abs(x[0]) > 1.5 * self._rhoMax) or (iter > maxIter):
                fitFailure = True
                break
            oldChi2 = chi2
            iter += 1
 
        outline = Line(x[0], x[1], abs(x[2])**-1)
 
        return outline, chi2, fitFailure
 
 

◆ makeProfile()

lsst.pipe.tasks.maskStreaks.LineProfile.makeProfile	(	self,
		line,
		fitFlux = True )

Construct the line profile model.

Parameters
----------
line : `Line`
    Parameters of the line profile to model.
fitFlux : `bool`, optional
    Fit the amplitude of the line profile to the data.

Returns
-------
finalModel : `np.ndarray`
    Model for line profile.

Definition at line 308 of file maskStreaks.py.

    def makeProfile(self, line, fitFlux=True):
        """Construct the line profile model.
 
        Parameters
        ----------
        line : `Line`
            Parameters of the line profile to model.
        fitFlux : `bool`, optional
            Fit the amplitude of the line profile to the data.
 
        Returns
        -------
        finalModel : `np.ndarray`
            Model for line profile.
        """
        model, _ = self._makeMaskedProfile(line, fitFlux=fitFlux)
        finalModel = np.zeros((self._ymax, self._xmax), dtype=self._dtype)
        finalModel[self.lineMask] = model
        return finalModel
 

◆ setLineMask()

lsst.pipe.tasks.maskStreaks.LineProfile.setLineMask	(		self,
			line )

Set mask around the image region near the line.

Parameters
----------
line : `Line`
    Parameters of line in the image.

Definition at line 227 of file maskStreaks.py.

    def setLineMask(self, line):
        """Set mask around the image region near the line.
 
        Parameters
        ----------
        line : `Line`
            Parameters of line in the image.
        """
        if line:
            # Only fit pixels within 5 sigma of the estimated line
            radtheta = np.deg2rad(line.theta)
            distance = (np.cos(radtheta) * self._xmesh + np.sin(radtheta) * self._ymesh - line.rho)
            m = (abs(distance) < 5 * line.sigma)
            self.lineMask = self.mask & m
        else:
            self.lineMask = np.copy(self.mask)
 
        self.lineMaskSize = self.lineMask.sum()
        self._maskData = self.data[self.lineMask]
        self._maskWeights = self.weights[self.lineMask]
        self._mxmesh = self._xmesh[self.lineMask]
        self._mymesh = self._ymesh[self.lineMask]
 

Member Data Documentation

◆ _dtype

lsst.pipe.tasks.maskStreaks.LineProfile._dtype

protected

Definition at line 217 of file maskStreaks.py.

◆ _initLine

lsst.pipe.tasks.maskStreaks.LineProfile._initLine

protected

Definition at line 224 of file maskStreaks.py.

◆ _maskData

lsst.pipe.tasks.maskStreaks.LineProfile._maskData

protected

Definition at line 245 of file maskStreaks.py.

◆ _maskWeights

lsst.pipe.tasks.maskStreaks.LineProfile._maskWeights

protected

Definition at line 246 of file maskStreaks.py.

◆ _mxmesh

lsst.pipe.tasks.maskStreaks.LineProfile._mxmesh

protected

Definition at line 247 of file maskStreaks.py.

◆ _mymesh

lsst.pipe.tasks.maskStreaks.LineProfile._mymesh

protected

Definition at line 248 of file maskStreaks.py.

◆ _rhoMax

lsst.pipe.tasks.maskStreaks.LineProfile._rhoMax

protected

Definition at line 220 of file maskStreaks.py.

◆ _xmax

lsst.pipe.tasks.maskStreaks.LineProfile._xmax

protected

Definition at line 216 of file maskStreaks.py.

◆ _xmesh

lsst.pipe.tasks.maskStreaks.LineProfile._xmesh

protected

Definition at line 221 of file maskStreaks.py.

◆ _ymax

lsst.pipe.tasks.maskStreaks.LineProfile._ymax

protected

Definition at line 216 of file maskStreaks.py.

◆ _ymesh

lsst.pipe.tasks.maskStreaks.LineProfile._ymesh

protected

Definition at line 221 of file maskStreaks.py.

◆ data

lsst.pipe.tasks.maskStreaks.LineProfile.data

Definition at line 214 of file maskStreaks.py.

◆ lineMask

lsst.pipe.tasks.maskStreaks.LineProfile.lineMask

Definition at line 240 of file maskStreaks.py.

◆ lineMaskSize

lsst.pipe.tasks.maskStreaks.LineProfile.lineMaskSize

Definition at line 244 of file maskStreaks.py.

◆ mask

lsst.pipe.tasks.maskStreaks.LineProfile.mask

Definition at line 222 of file maskStreaks.py.

◆ weights

lsst.pipe.tasks.maskStreaks.LineProfile.weights

Definition at line 215 of file maskStreaks.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/pipe_tasks/g06b2ea86fd+734f9505a2/python/lsst/pipe/tasks/maskStreaks.py

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _lineChi2()

◆ _makeMaskedProfile()

◆ fit()

◆ makeProfile()

◆ setLineMask()

Member Data Documentation

◆ _dtype

◆ _initLine

◆ _maskData

◆ _maskWeights

◆ _mxmesh

◆ _mymesh

◆ _rhoMax

◆ _xmax

◆ _xmesh

◆ _ymax

◆ _ymesh

◆ data

◆ lineMask

◆ lineMaskSize

◆ mask

◆ weights

◆ init()