lsst::ip::diffim::StaticKernelSolution< InputT > Class Template Reference

#include <KernelSolution.h>

Inheritance diagram for lsst::ip::diffim::StaticKernelSolution< InputT >:

Public Types
typedef std::shared_ptr< StaticKernelSolution< InputT > >	Ptr
enum	KernelSolvedBy {   NONE = 0 , CHOLESKY_LDLT = 1 , CHOLESKY_LLT = 2 , LU = 3 ,   EIGENVECTOR = 4 }
enum	ConditionNumberType { EIGENVALUE = 0 , SVD = 1 }
typedef lsst::afw::math::Kernel::Pixel	PixelT
typedef lsst::afw::image::Image< lsst::afw::math::Kernel::Pixel >	ImageT

Public Member Functions
	StaticKernelSolution (lsst::afw::math::KernelList const &basisList, bool fitForBackground)
virtual	~StaticKernelSolution ()
void	solve ()
virtual void	build (lsst::afw::image::Image< InputT > const &templateImage, lsst::afw::image::Image< InputT > const &scienceImage, lsst::afw::image::Image< lsst::afw::image::VariancePixel > const &varianceEstimate)
virtual std::shared_ptr< lsst::afw::math::Kernel >	getKernel ()
virtual std::shared_ptr< lsst::afw::image::Image< lsst::afw::math::Kernel::Pixel > >	makeKernelImage ()
virtual double	getBackground ()
virtual double	getKsum ()
virtual std::pair< std::shared_ptr< lsst::afw::math::Kernel >, double >	getSolutionPair ()
virtual void	solve (Eigen::MatrixXd const &mMat, Eigen::VectorXd const &bVec)
KernelSolvedBy	getSolvedBy ()
virtual double	getConditionNumber (ConditionNumberType conditionType)
virtual double	getConditionNumber (Eigen::MatrixXd const &mMat, ConditionNumberType conditionType)
Eigen::MatrixXd const &	getM ()
Eigen::VectorXd const &	getB ()
void	printM ()
void	printB ()
void	printA ()
int	getId () const

Protected Member Functions
void	_setKernel ()
	Set kernel after solution.
void	_setKernelUncertainty ()
	Not implemented.

Protected Attributes
Eigen::MatrixXd	_cMat
	K_i x R.
Eigen::VectorXd	_iVec
	Vectorized I.
Eigen::VectorXd	_ivVec
	Inverse variance.
std::shared_ptr< lsst::afw::math::Kernel >	_kernel
	Derived single-object convolution kernel.
double	_background
	Derived differential background estimate.
double	_kSum
	Derived kernel sum.
int	_id
	Unique ID for object.
Eigen::MatrixXd	_mMat
	Derived least squares M matrix.
Eigen::VectorXd	_bVec
	Derived least squares B vector.
Eigen::VectorXd	_aVec
	Derived least squares solution matrix.
KernelSolvedBy	_solvedBy
	Type of algorithm used to make solution.
bool	_fitForBackground
	Background terms included in fit.

Static Protected Attributes
static int	_SolutionId = 0
	Unique identifier for solution.

Detailed Description

template<typename InputT>
class lsst::ip::diffim::StaticKernelSolution< InputT >

Definition at line 83 of file KernelSolution.h.

Member Typedef Documentation

ImageT

typedef lsst::afw::image::Image<lsst::afw::math::Kernel::Pixel> lsst::ip::diffim::KernelSolution::ImageT

inherited

Definition at line 35 of file KernelSolution.h.

PixelT

typedef lsst::afw::math::Kernel::Pixel lsst::ip::diffim::KernelSolution::PixelT

inherited

Definition at line 34 of file KernelSolution.h.

Ptr

template<typename InputT>

typedef std::shared_ptr<StaticKernelSolution<InputT> > lsst::ip::diffim::StaticKernelSolution< InputT >::Ptr

Definition at line 85 of file KernelSolution.h.

Member Enumeration Documentation

ConditionNumberType

enum lsst::ip::diffim::KernelSolution::ConditionNumberType

inherited

Enumerator
EIGENVALUE
SVD

Definition at line 45 of file KernelSolution.h.

                                 {
            EIGENVALUE = 0,
            SVD        = 1
        };

KernelSolvedBy

enum lsst::ip::diffim::KernelSolution::KernelSolvedBy

inherited

Enumerator
NONE
CHOLESKY_LDLT
CHOLESKY_LLT
LU
EIGENVECTOR

Definition at line 37 of file KernelSolution.h.

                            {
            NONE          = 0,
            CHOLESKY_LDLT = 1,
            CHOLESKY_LLT  = 2,
            LU            = 3,
            EIGENVECTOR   = 4
        };

Constructor & Destructor Documentation

StaticKernelSolution()

template<typename InputT>

lsst::ip::diffim::StaticKernelSolution< InputT >::StaticKernelSolution	(	lsst::afw::math::KernelList const &	basisList,
		bool	fitForBackground )

Definition at line 195 of file KernelSolution.cc.

        :
        KernelSolution(fitForBackground),
        _cMat(),
        _iVec(),
        _ivVec(),
        _kernel(),
        _background(0.0),
        _kSum(0.0)
    {
        std::vector<double> kValues(basisList.size());
        _kernel = std::shared_ptr<afwMath::Kernel>(
            new afwMath::LinearCombinationKernel(basisList, kValues)
            );
    };

~StaticKernelSolution()

template<typename InputT>

virtual lsst::ip::diffim::StaticKernelSolution< InputT >::~StaticKernelSolution ( )

inlinevirtual

Definition at line 89 of file KernelSolution.h.

{};

Member Function Documentation

_setKernel()

template<typename InputT>

void lsst::ip::diffim::StaticKernelSolution< InputT >::_setKernel ( )

protected

Set kernel after solution.

Definition at line 423 of file KernelSolution.cc.

                                                  {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot make solution");
        }
 
        unsigned int const nParameters           = _aVec.size();
        unsigned int const nBackgroundParameters = _fitForBackground ? 1 : 0;
        unsigned int const nKernelParameters     =
            std::dynamic_pointer_cast<afwMath::LinearCombinationKernel>(_kernel)->getKernelList().size();
        if (nParameters != (nKernelParameters + nBackgroundParameters))
            throw LSST_EXCEPT(pexExcept::Exception, "Mismatched sizes in kernel solution");
 
        /* Fill in the kernel results */
        std::vector<double> kValues(nKernelParameters);
        for (unsigned int idx = 0; idx < nKernelParameters; idx++) {
            if (std::isnan(_aVec(idx))) {
                throw LSST_EXCEPT(pexExcept::Exception,
                                  str(boost::format("Unable to determine kernel solution %d (nan)") % idx));
            }
            kValues[idx] = _aVec(idx);
        }
        _kernel->setKernelParameters(kValues);
 
        std::shared_ptr<ImageT> image (
            new ImageT(_kernel->getDimensions())
            );
        _kSum  = _kernel->computeImage(*image, false);
 
        if (_fitForBackground) {
            if (std::isnan(_aVec(nParameters-1))) {
                throw LSST_EXCEPT(pexExcept::Exception,
                                  str(boost::format("Unable to determine background solution %d (nan)") %
                                      (nParameters-1)));
            }
            _background = _aVec(nParameters-1);
        }
    }

_setKernelUncertainty()

template<typename InputT>

void lsst::ip::diffim::StaticKernelSolution< InputT >::_setKernelUncertainty ( )

protected

Not implemented.

Definition at line 463 of file KernelSolution.cc.

                                                             {
        throw LSST_EXCEPT(pexExcept::Exception, "Uncertainty calculation not supported");
 
        /* Estimate of parameter uncertainties comes from the inverse of the
         * covariance matrix (noise spectrum).
         * N.R. 15.4.8 to 15.4.15
         *
         * Since this is a linear problem no need to use Fisher matrix
         * N.R. 15.5.8
         *
         * Although I might be able to take advantage of the solution above.
         * Since this now works and is not the rate limiting step, keep as-is for DC3a.
         *
         * Use Cholesky decomposition again.
         * Cholkesy:
         * Cov       =  L L^t
         * Cov^(-1)  = (L L^t)^(-1)
         *           = (L^T)^-1 L^(-1)
         *
         * Code would be:
         *
         * Eigen::MatrixXd             cov    = _mMat.transpose() * _mMat;
         * Eigen::LLT<Eigen::MatrixXd> llt    = cov.llt();
         * Eigen::MatrixXd             error2 = llt.matrixL().transpose().inverse()*llt.matrixL().inverse();
         */
    }

build()

template<typename InputT>

void lsst::ip::diffim::StaticKernelSolution< InputT >::build ( lsst::afw::image::Image< InputT > const & templateImage, lsst::afw::image::Image< InputT > const & scienceImage, lsst::afw::image::Image< lsst::afw::image::VariancePixel > const & varianceEstimate )

virtual

Definition at line 261 of file KernelSolution.cc.

          {
 
        afwMath::Statistics varStats = afwMath::makeStatistics(varianceEstimate, afwMath::MIN);
        if (varStats.getValue(afwMath::MIN) < 0.0) {
            throw LSST_EXCEPT(pexExcept::Exception,
                              "Error: variance less than 0.0");
        }
        if (varStats.getValue(afwMath::MIN) == 0.0) {
            throw LSST_EXCEPT(pexExcept::Exception,
                              "Error: variance equals 0.0, cannot inverse variance weight");
        }
 
        lsst::afw::math::KernelList basisList =
            std::dynamic_pointer_cast<afwMath::LinearCombinationKernel>(_kernel)->getKernelList();
 
        unsigned int const nKernelParameters     = basisList.size();
        unsigned int const nBackgroundParameters = _fitForBackground ? 1 : 0;
        unsigned int const nParameters           = nKernelParameters + nBackgroundParameters;
 
        std::vector<std::shared_ptr<afwMath::Kernel> >::const_iterator kiter = basisList.begin();
 
        /* Ignore buffers around edge of convolved images :
         *
         * If the kernel has width 5, it has center pixel 2.  The first good pixel
         * is the (5-2)=3rd pixel, which is array index 2, and ends up being the
         * index of the central pixel.
         *
         * You also have a buffer of unusable pixels on the other side, numbered
         * width-center-1.  The last good usable pixel is N-width+center+1.
         *
         * Example : the kernel is width = 5, center = 2
         *
         * ---|---|-c-|---|---|
         *
         * the image is width = N
         * convolve this with the kernel, and you get
         *
         * |-x-|-x-|-g-|---|---| ... |---|---|-g-|-x-|-x-|
         *
         * g = first/last good pixel
         * x = bad
         *
         * the first good pixel is the array index that has the value "center", 2
         * the last good pixel has array index N-(5-2)+1
         * eg. if N = 100, you want to use up to index 97
         * 100-3+1 = 98, and the loops use i < 98, meaning the last
         * index you address is 97.
         */
 
        /* NOTE - we are accessing particular elements of Eigen arrays using
           these coordinates, therefore they need to be in LOCAL coordinates.
           This was written before ndarray unification.
        */
        geom::Box2I goodBBox = (*kiter)->shrinkBBox(templateImage.getBBox(afwImage::LOCAL));
        unsigned int const startCol = goodBBox.getMinX();
        unsigned int const startRow = goodBBox.getMinY();
        // endCol/Row is one past the index of the last good col/row
        unsigned int endCol = goodBBox.getMaxX() + 1;
        unsigned int endRow = goodBBox.getMaxY() + 1;
 
        boost::timer::cpu_timer t;
 
        /* Eigen representation of input images; only the pixels that are unconvolved in cimage below */
        Eigen::MatrixXd eigenTemplate = imageToEigenMatrix(templateImage).block(startRow,
                                                                                startCol,
                                                                                endRow-startRow,
                                                                                endCol-startCol);
        Eigen::MatrixXd eigenScience = imageToEigenMatrix(scienceImage).block(startRow,
                                                                              startCol,
                                                                              endRow-startRow,
                                                                              endCol-startCol);
        Eigen::MatrixXd eigeniVariance = imageToEigenMatrix(varianceEstimate).block(
            startRow, startCol, endRow-startRow, endCol-startCol
        ).array().inverse().matrix();
 
        /* Resize into 1-D for later usage */
        eigenTemplate.resize(eigenTemplate.rows()*eigenTemplate.cols(), 1);
        eigenScience.resize(eigenScience.rows()*eigenScience.cols(), 1);
        eigeniVariance.resize(eigeniVariance.rows()*eigeniVariance.cols(), 1);
 
        /* Holds image convolved with basis function */
        afwImage::Image<PixelT> cimage(templateImage.getDimensions());
 
        /* Holds eigen representation of image convolved with all basis functions */
        std::vector<Eigen::MatrixXd> convolvedEigenList(nKernelParameters);
 
        /* Iterators over convolved image list and basis list */
        typename std::vector<Eigen::MatrixXd>::iterator eiter = convolvedEigenList.begin();
        /* Create C_i in the formalism of Alard & Lupton */
        afwMath::ConvolutionControl convolutionControl;
        convolutionControl.setDoNormalize(false);
        for (kiter = basisList.begin(); kiter != basisList.end(); ++kiter, ++eiter) {
            afwMath::convolve(cimage, templateImage, **kiter, convolutionControl); /* cimage stores convolved image */
 
            Eigen::MatrixXd cMat = imageToEigenMatrix(cimage).block(startRow,
                                                                    startCol,
                                                                    endRow-startRow,
                                                                    endCol-startCol);
            cMat.resize(cMat.size(), 1);
            *eiter = cMat;
 
        }
 
        t.stop();
        double time = 1e-9 * t.elapsed().wall;
        LOGL_DEBUG("TRACE3.ip.diffim.StaticKernelSolution.build",
                   "Total compute time to do basis convolutions : %.2f s", time);
 
        /*
           Load matrix with all values from convolvedEigenList : all images
           (eigeniVariance, convolvedEigenList) must be the same size
        */
        Eigen::MatrixXd cMat(eigenTemplate.col(0).size(), nParameters);
        typename std::vector<Eigen::MatrixXd>::iterator eiterj = convolvedEigenList.begin();
        typename std::vector<Eigen::MatrixXd>::iterator eiterE = convolvedEigenList.end();
        for (unsigned int kidxj = 0; eiterj != eiterE; eiterj++, kidxj++) {
            cMat.col(kidxj) = eiterj->col(0);
        }
        /* Treat the last "image" as all 1's to do the background calculation. */
        if (_fitForBackground)
            cMat.col(nParameters-1).fill(1.);
 
        _cMat = cMat;
        _ivVec = eigeniVariance.col(0);
        _iVec = eigenScience.col(0);
 
        /* Make these outside of solve() so I can check condition number */
        _mMat = _cMat.transpose() * (_ivVec.asDiagonal() * _cMat);
        _bVec = _cMat.transpose() * (_ivVec.asDiagonal() * _iVec);
    }

getB()

Eigen::VectorXd const & lsst::ip::diffim::KernelSolution::getB ( )

inlineinherited

Definition at line 65 of file KernelSolution.h.

{return _bVec;}

getBackground()

template<typename InputT>

double lsst::ip::diffim::StaticKernelSolution< InputT >::getBackground ( )

virtual

Definition at line 235 of file KernelSolution.cc.

                                                       {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot return background");
        }
        return _background;
    }

getConditionNumber() [1/2]

double lsst::ip::diffim::KernelSolution::getConditionNumber ( ConditionNumberType conditionType )

virtualinherited

Definition at line 94 of file KernelSolution.cc.

                                                                               {
        return getConditionNumber(_mMat, conditionType);
    }

getConditionNumber() [2/2]

double lsst::ip::diffim::KernelSolution::getConditionNumber ( Eigen::MatrixXd const & mMat, ConditionNumberType conditionType )

virtualinherited

Definition at line 98 of file KernelSolution.cc.

                                                                                 {
        switch (conditionType) {
        case EIGENVALUE:
            {
            Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eVecValues(mMat);
            Eigen::VectorXd eValues = eVecValues.eigenvalues();
            double eMax = eValues.maxCoeff();
            double eMin = eValues.minCoeff();
            LOGL_DEBUG("TRACE3.ip.diffim.KernelSolution.getConditionNumber",
                       "EIGENVALUE eMax / eMin = %.3e", eMax / eMin);
            return (eMax / eMin);
            break;
            }
        case SVD:
            {
            Eigen::VectorXd sValues = mMat.jacobiSvd().singularValues();
            double sMax = sValues.maxCoeff();
            double sMin = sValues.minCoeff();
            LOGL_DEBUG("TRACE3.ip.diffim.KernelSolution.getConditionNumber",
                       "SVD eMax / eMin = %.3e", sMax / sMin);
            return (sMax / sMin);
            break;
            }
        default:
            {
            throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                              "Undefined ConditionNumberType : only EIGENVALUE, SVD allowed.");
            break;
            }
        }
    }

getId()

int lsst::ip::diffim::KernelSolution::getId ( ) const

inlineinherited

Definition at line 69 of file KernelSolution.h.

{ return _id; }

getKernel()

template<typename InputT>

std::shared_ptr< lsst::afw::math::Kernel > lsst::ip::diffim::StaticKernelSolution< InputT >::getKernel ( )

virtual

Definition at line 215 of file KernelSolution.cc.

                                                                             {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot return solution");
        }
        return _kernel;
    }

getKsum()

template<typename InputT>

double lsst::ip::diffim::StaticKernelSolution< InputT >::getKsum ( )

virtual

Definition at line 243 of file KernelSolution.cc.

                                                 {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot return ksum");
        }
        return _kSum;
    }

getM()

Eigen::MatrixXd const & lsst::ip::diffim::KernelSolution::getM ( )

inlineinherited

Definition at line 64 of file KernelSolution.h.

{return _mMat;}

getSolutionPair()

template<typename InputT>

std::pair< std::shared_ptr< lsst::afw::math::Kernel >, double > lsst::ip::diffim::StaticKernelSolution< InputT >::getSolutionPair ( )

virtual

Definition at line 252 of file KernelSolution.cc.

                                                  {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot return solution");
        }
 
        return std::make_pair(_kernel, _background);
    }

getSolvedBy()

KernelSolvedBy lsst::ip::diffim::KernelSolution::getSolvedBy ( )

inlineinherited

Definition at line 60 of file KernelSolution.h.

{return _solvedBy;}

makeKernelImage()

template<typename InputT>

std::shared_ptr< lsst::afw::image::Image< lsst::afw::math::Kernel::Pixel > > lsst::ip::diffim::StaticKernelSolution< InputT >::makeKernelImage ( )

virtual

Definition at line 223 of file KernelSolution.cc.

                                                                                                           {
        if (_solvedBy == KernelSolution::NONE) {
            throw LSST_EXCEPT(pexExcept::Exception, "Kernel not solved; cannot return image");
        }
        std::shared_ptr<afwImage::Image<afwMath::Kernel::Pixel>> image(
            new afwImage::Image<afwMath::Kernel::Pixel>(_kernel->getDimensions())
            );
        (void)_kernel->computeImage(*image, false);
        return image;
    }

printA()

void lsst::ip::diffim::KernelSolution::printA ( )

inlineinherited

Definition at line 68 of file KernelSolution.h.

{std::cout << _aVec << std::endl;}

printB()

void lsst::ip::diffim::KernelSolution::printB ( )

inlineinherited

Definition at line 67 of file KernelSolution.h.

{std::cout << _bVec << std::endl;}

printM()

void lsst::ip::diffim::KernelSolution::printM ( )

inlineinherited

Definition at line 66 of file KernelSolution.h.

{std::cout << _mMat << std::endl;}

solve() [1/2]

void lsst::ip::diffim::KernelSolution::solve ( Eigen::MatrixXd const & mMat, Eigen::VectorXd const & bVec )

virtualinherited

Definition at line 131 of file KernelSolution.cc.

                                                          {
 
        if (DEBUG_MATRIX) {
            std::cout << "M " << std::endl;
            std::cout << mMat << std::endl;
            std::cout << "B " << std::endl;
            std::cout << bVec << std::endl;
        }
 
        Eigen::VectorXd aVec = Eigen::VectorXd::Zero(bVec.size());
 
        boost::timer::cpu_timer t;
 
        LOGL_DEBUG("TRACE2.ip.diffim.KernelSolution.solve",
                   "Solving for kernel");
                _solvedBy = LU;
                Eigen::FullPivLU<Eigen::MatrixXd> lu(mMat);
                if (lu.isInvertible()) {
                        aVec = lu.solve(bVec);
                } else {
                        LOGL_DEBUG("TRACE3.ip.diffim.KernelSolution.solve",
                                   "Unable to determine kernel via LU");
                        /* LAST RESORT */
                        try {
 
                                _solvedBy = EIGENVECTOR;
                                Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eVecValues(mMat);
                                Eigen::MatrixXd const& rMat = eVecValues.eigenvectors();
                                Eigen::VectorXd eValues = eVecValues.eigenvalues();
 
                                for (int i = 0; i != eValues.rows(); ++i) {
                                        if (eValues(i) != 0.0) {
                                                eValues(i) = 1.0/eValues(i);
                                        }
                                }
 
                                aVec = rMat * eValues.asDiagonal() * rMat.transpose() * bVec;
                        } catch (pexExcept::Exception& e) {
 
                                _solvedBy = NONE;
                                LOGL_DEBUG("TRACE3.ip.diffim.KernelSolution.solve",
                                           "Unable to determine kernel via eigen-values");
 
                                throw LSST_EXCEPT(pexExcept::Exception, "Unable to determine kernel solution");
                        }
                }
 
        t.stop();
        double time = 1e-9 * t.elapsed().wall;
        LOGL_DEBUG("TRACE3.ip.diffim.KernelSolution.solve",
                   "Compute time for matrix math : %.2f s", time);
 
        if (DEBUG_MATRIX) {
                  std::cout << "A " << std::endl;
            std::cout << aVec << std::endl;
        }
 
        _aVec = aVec;
    }

solve() [2/2]

template<typename InputT>

void lsst::ip::diffim::StaticKernelSolution< InputT >::solve ( )

virtual

Reimplemented from lsst::ip::diffim::KernelSolution.

Definition at line 397 of file KernelSolution.cc.

                                             {
        LOGL_DEBUG("TRACE3.ip.diffim.StaticKernelSolution.solve",
                   "mMat is %d x %d; bVec is %d; cMat is %d x %d; vVec is %d; iVec is %d",
                   _mMat.rows(), _mMat.cols(), _bVec.size(),
                   _cMat.rows(), _cMat.cols(), _ivVec.size(), _iVec.size());
 
        if (DEBUG_MATRIX) {
            std::cout << "C" << std::endl;
            std::cout << _cMat << std::endl;
            std::cout << "iV" << std::endl;
            std::cout << _ivVec << std::endl;
            std::cout << "I" << std::endl;
            std::cout << _iVec << std::endl;
        }
 
        try {
            KernelSolution::solve();
        } catch (pexExcept::Exception &e) {
            LSST_EXCEPT_ADD(e, "Unable to solve static kernel matrix");
            throw e;
        }
        /* Turn matrices into _kernel and _background */
        _setKernel();
    }

Member Data Documentation

_aVec

Eigen::VectorXd lsst::ip::diffim::KernelSolution::_aVec

protectedinherited

Derived least squares solution matrix.

Definition at line 75 of file KernelSolution.h.

_background

template<typename InputT>

double lsst::ip::diffim::StaticKernelSolution< InputT >::_background

protected

Derived differential background estimate.

Definition at line 110 of file KernelSolution.h.

_bVec

Eigen::VectorXd lsst::ip::diffim::KernelSolution::_bVec

protectedinherited

Derived least squares B vector.

Definition at line 74 of file KernelSolution.h.

_cMat

template<typename InputT>

Eigen::MatrixXd lsst::ip::diffim::StaticKernelSolution< InputT >::_cMat

protected

K_i x R.

Definition at line 105 of file KernelSolution.h.

_fitForBackground

bool lsst::ip::diffim::KernelSolution::_fitForBackground

protectedinherited

Background terms included in fit.

Definition at line 77 of file KernelSolution.h.

_id

int lsst::ip::diffim::KernelSolution::_id

protectedinherited

Unique ID for object.

Definition at line 72 of file KernelSolution.h.

_iVec

template<typename InputT>

Eigen::VectorXd lsst::ip::diffim::StaticKernelSolution< InputT >::_iVec

protected

Vectorized I.

Definition at line 106 of file KernelSolution.h.

_ivVec

template<typename InputT>

Eigen::VectorXd lsst::ip::diffim::StaticKernelSolution< InputT >::_ivVec

protected

Inverse variance.

Definition at line 107 of file KernelSolution.h.

_kernel

template<typename InputT>

std::shared_ptr<lsst::afw::math::Kernel> lsst::ip::diffim::StaticKernelSolution< InputT >::_kernel

protected

Derived single-object convolution kernel.

Definition at line 109 of file KernelSolution.h.

_kSum

template<typename InputT>

double lsst::ip::diffim::StaticKernelSolution< InputT >::_kSum

protected

Derived kernel sum.

Definition at line 111 of file KernelSolution.h.

_mMat

Eigen::MatrixXd lsst::ip::diffim::KernelSolution::_mMat

protectedinherited

Derived least squares M matrix.

Definition at line 73 of file KernelSolution.h.

_SolutionId

int lsst::ip::diffim::KernelSolution::_SolutionId = 0

staticprotectedinherited

Unique identifier for solution.

Definition at line 78 of file KernelSolution.h.

_solvedBy

KernelSolvedBy lsst::ip::diffim::KernelSolution::_solvedBy

protectedinherited

Type of algorithm used to make solution.

Definition at line 76 of file KernelSolution.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/ip_diffim/g7cc15d900a+d121454f8d/include/lsst/ip/diffim/KernelSolution.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/ip_diffim/g7cc15d900a+d121454f8d/src/KernelSolution.cc