lsst::ip::diffim::KernelCandidate< _PixelT > Class Template Reference

Class stored in SpatialCells for spatial Kernel fitting. More...

#include <KernelCandidate.h>

Inheritance diagram for lsst::ip::diffim::KernelCandidate< _PixelT >:

Public Types
enum	CandidateSwitch { ORIG = 0, PCA = 1, RECENT = 2 }
typedef afw::image::Image < afw::math::Kernel::Pixel >	ImageT
typedef _PixelT	PixelT
typedef boost::shared_ptr < KernelCandidate >	Ptr
typedef boost::shared_ptr < afw::image::MaskedImage < PixelT > >	MaskedImagePtr
typedef boost::shared_ptr < afw::image::Image < afw::image::VariancePixel > >	VariancePtr
typedef boost::shared_ptr < afw::table::SourceRecord >	SourcePtr
Public Types inherited from lsst.afw.math::SpatialCellImageCandidate< afw::math::Kernel::Pixel >
typedef boost::shared_ptr < SpatialCellImageCandidate >	Ptr
typedef boost::shared_ptr < const SpatialCellImageCandidate >	ConstPtr
Public Types inherited from lsst.afw.math::SpatialCellCandidate
enum	Status { BAD = 0, GOOD = 1, UNKNOWN = 2 }
typedef boost::shared_ptr < SpatialCellCandidate >	Ptr
typedef boost::shared_ptr < const SpatialCellCandidate >	ConstPtr

Public Member Functions
	KernelCandidate (float const xCenter, float const yCenter, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage, pex::policy::Policy const &policy)
	Constructor. More...
	KernelCandidate (SourcePtr const &source, MaskedImagePtr const &templateMaskedImage, MaskedImagePtr const &scienceMaskedImage, pex::policy::Policy const &policy)
	Constructor. More...
virtual	~KernelCandidate ()
	Destructor. More...
double	getCandidateRating () const
	Return Candidate rating. More...
SourcePtr	getSource () const
	Return the original source. More...
MaskedImagePtr	getTemplateMaskedImage ()
	Return pointers to the image pixels used in kernel determination. More...
MaskedImagePtr	getScienceMaskedImage ()
afw::math::Kernel::Ptr	getKernel (CandidateSwitch cand) const
	Return results of kernel solution. More...
double	getBackground (CandidateSwitch cand) const
double	getKsum (CandidateSwitch cand) const
boost::shared_ptr< ImageT >	getKernelImage (CandidateSwitch cand) const
boost::shared_ptr< ImageT const >	getImage () const
	Return the Candidate's Image. More...
boost::shared_ptr < StaticKernelSolution< PixelT > >	getKernelSolution (CandidateSwitch cand) const
afw::image::MaskedImage< PixelT >	getDifferenceImage (CandidateSwitch cand)
	Calculate associated difference image using internal solutions. More...
afw::image::MaskedImage< PixelT >	getDifferenceImage (afw::math::Kernel::Ptr kernel, double background)
	Calculate associated difference image using input kernel and background. More...
bool	isInitialized () const
void	build (afw::math::KernelList const &basisList)
	Core functionality of KernelCandidate, to build and fill a KernelSolution. More...
void	build (afw::math::KernelList const &basisList, boost::shared_ptr< Eigen::MatrixXd > hMat)
Public Member Functions inherited from lsst.afw.math::SpatialCellImageCandidate< afw::math::Kernel::Pixel >
	SpatialCellImageCandidate (float const xCenter, float const yCenter)
	ctor More...
virtual	~SpatialCellImageCandidate ()
double	getChi2 () const
	Return the candidate's chi^2. More...
void	setChi2 (double chi2)
	Set the candidate's chi^2. More...
Public Member Functions inherited from lsst.afw.math::SpatialCellCandidate
	SpatialCellCandidate (float const xCenter, float const yCenter)
virtual	~SpatialCellCandidate ()
float	getXCenter () const
	Return the object's column-centre. More...
float	getYCenter () const
	Return the object's row-centre. More...
virtual bool	instantiate ()
	Do anything needed to make this candidate usable. More...
virtual void	setCandidateRating (double)
	Set the candidate's rating. More...
int	getId () const
	Return the candidate's unique ID. More...
Status	getStatus () const
	Return the candidate's status. More...
void	setStatus (Status status)
	Set the candidate's status. More...
virtual bool	isBad () const
	Is this candidate unacceptable? More...

Private Member Functions
void	_buildKernelSolution (afw::math::KernelList const &basisList, boost::shared_ptr< Eigen::MatrixXd > hMat)

Private Attributes
MaskedImagePtr	_templateMaskedImage
	Subimage around which you build kernel. More...
MaskedImagePtr	_scienceMaskedImage
	Subimage around which you build kernel. More...
VariancePtr	_varianceEstimate
	Estimate of the local variance. More...
pex::policy::Policy	_policy
	Policy. More...
SourcePtr	_source
double	_coreFlux
	Mean S/N in the science image. More...
bool	_isInitialized
	Has the kernel been built. More...
bool	_useRegularization
	Use regularization? More...
bool	_fitForBackground
boost::shared_ptr < StaticKernelSolution< PixelT > >	_kernelSolutionOrig
	Original basis solution. More...
boost::shared_ptr < StaticKernelSolution< PixelT > >	_kernelSolutionPca
	Most recent solution. More...

Additional Inherited Members
Static Public Member Functions inherited from lsst.afw.math::SpatialCellImageCandidate< afw::math::Kernel::Pixel >
static void	setWidth (int width)
	Set the width of the image that getImage should return. More...
static int	getWidth ()
	Return the width of the image that getImage should return. More...
static void	setHeight (int height)
	Set the height of the image that getImage should return. More...
static int	getHeight ()
	Return the height of the image that getImage should return. More...
Protected Attributes inherited from lsst.afw.math::SpatialCellImageCandidate< afw::math::Kernel::Pixel >
boost::shared_ptr < lsst::afw::image::Image < afw::math::Kernel::Pixel > >	_image
	a pointer to the Image, for the use of the base class More...

Detailed Description

template<typename _PixelT>
class lsst::ip::diffim::KernelCandidate< _PixelT >

Class stored in SpatialCells for spatial Kernel fitting.

Note

KernelCandidate is a single Kernel derived around a source. We'll assign them to sets of SpatialCells; these sets will then be used to fit a spatial model to the Kernel.

Definition at line 38 of file KernelCandidate.h.

Member Typedef Documentation

template<typename _PixelT>

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

Definition at line 41 of file KernelCandidate.h.

template<typename _PixelT>

typedef boost::shared_ptr<afw::image::MaskedImage<PixelT> > lsst::ip::diffim::KernelCandidate< _PixelT >::MaskedImagePtr

Definition at line 49 of file KernelCandidate.h.

template<typename _PixelT>

typedef _PixelT lsst::ip::diffim::KernelCandidate< _PixelT >::PixelT

Definition at line 42 of file KernelCandidate.h.

template<typename _PixelT>

typedef boost::shared_ptr<KernelCandidate> lsst::ip::diffim::KernelCandidate< _PixelT >::Ptr

Definition at line 48 of file KernelCandidate.h.

template<typename _PixelT>

typedef boost::shared_ptr<afw::table::SourceRecord> lsst::ip::diffim::KernelCandidate< _PixelT >::SourcePtr

Definition at line 51 of file KernelCandidate.h.

template<typename _PixelT>

typedef boost::shared_ptr<afw::image::Image<afw::image::VariancePixel> > lsst::ip::diffim::KernelCandidate< _PixelT >::VariancePtr

Definition at line 50 of file KernelCandidate.h.

Member Enumeration Documentation

template<typename _PixelT>

enum lsst::ip::diffim::KernelCandidate::CandidateSwitch

Enumerator
ORIG
PCA
RECENT

Definition at line 53 of file KernelCandidate.h.

                             {
            ORIG    = 0,
            PCA     = 1,
            RECENT  = 2
        };

Constructor & Destructor Documentation

template<typename PixelT >

lsst::ip::diffim::KernelCandidate< PixelT >::KernelCandidate	(	float const	xCenter,
		float const	yCenter,
		MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage,
		pex::policy::Policy const &	policy
	)

Constructor.

Parameters

xCenter	Col position of object
yCenter	Row position of object
templateMaskedImage	Pointer to template image
scienceMaskedImage	Pointer to science image
policy	Policy file

Definition at line 35 of file KernelCandidate.cc.

          :
        lsst::afw::math::SpatialCellImageCandidate<lsst::afw::math::Kernel::Pixel>(xCenter, yCenter),
        _templateMaskedImage(templateMaskedImage),
        _scienceMaskedImage(scienceMaskedImage),
        _varianceEstimate(),
        _policy(policy),
        _source(),
        _coreFlux(),
        _isInitialized(false),
        _useRegularization(false),
        _fitForBackground(_policy.getBool("fitForBackground")),
        _kernelSolutionOrig(),
        _kernelSolutionPca()
    {

        /* Rank by mean core S/N in science image */
        ImageStatistics<PixelT> imstats(_policy);
        int candidateCoreRadius = _policy.getInt("candidateCoreRadius");
        try {
            imstats.apply(*_scienceMaskedImage, candidateCoreRadius);
        } catch (pexExcept::Exception& e) {
            pexLogging::TTrace<3>("lsst.ip.diffim.KernelCandidate",
                                  "Unable to calculate core imstats for ranking Candidate %d", this->getId()); 
            this->setStatus(afwMath::SpatialCellCandidate::BAD);
            return;
        }

        _coreFlux = imstats.getMean();
        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                          "Candidate %d at %.2f %.2f with ranking %.2f", 
                          this->getId(), this->getXCenter(), this->getYCenter(), _coreFlux);
    }

template<typename PixelT >

lsst::ip::diffim::KernelCandidate< PixelT >::KernelCandidate	(	SourcePtr const &	source,
		MaskedImagePtr const &	templateMaskedImage,
		MaskedImagePtr const &	scienceMaskedImage,
		pex::policy::Policy const &	policy
	)

Constructor.

Parameters

source	Pointer to a source to use in constructing the candidate
templateMaskedImage	Pointer to template image
scienceMaskedImage	Pointer to science image
policy	Policy file

Definition at line 75 of file KernelCandidate.cc.

          :
        lsst::afw::math::SpatialCellImageCandidate<lsst::afw::math::Kernel::Pixel>(source->getX(), source->getY()),
        _templateMaskedImage(templateMaskedImage),
        _scienceMaskedImage(scienceMaskedImage),
        _varianceEstimate(),
        _policy(policy),
        _source(source),
        _coreFlux(source->getPsfFlux()),
        _isInitialized(false),
        _useRegularization(false),
        _fitForBackground(_policy.getBool("fitForBackground")),
        _kernelSolutionOrig(),
        _kernelSolutionPca()
    {
        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                          "Candidate %d at %.2f %.2f with ranking %.2f", 
                          this->getId(), this->getXCenter(), this->getYCenter(), _coreFlux);
    }

template<typename _PixelT>

virtual lsst::ip::diffim::KernelCandidate< _PixelT >::~KernelCandidate ( )

inlinevirtual

Destructor.

Definition at line 88 of file KernelCandidate.h.

{};

Member Function Documentation

template<typename PixelT >

void lsst::ip::diffim::KernelCandidate< PixelT >::_buildKernelSolution ( afw::math::KernelList const &  basisList, boost::shared_ptr< Eigen::MatrixXd >  hMat  )

private

Definition at line 156 of file KernelCandidate.cc.

    {
        bool checkConditionNumber = _policy.getBool("checkConditionNumber");
        double maxConditionNumber = _policy.getDouble("maxConditionNumber");
        std::string conditionNumberType = _policy.getString("conditionNumberType");
        KernelSolution::ConditionNumberType ctype;
        if (conditionNumberType == "SVD") {
            ctype = KernelSolution::SVD;
        }
        else if (conditionNumberType == "EIGENVALUE") {
            ctype = KernelSolution::EIGENVALUE;
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "conditionNumberType not recognized");
        }

        /* Do we have a regularization matrix?  If so use it */
        if (hMat) {
            _useRegularization = true;
            pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate.build", 
                              "Using kernel regularization");

            if (_isInitialized) {
                _kernelSolutionPca = boost::shared_ptr<StaticKernelSolution<PixelT> >(
                    new RegularizedKernelSolution<PixelT>(basisList, _fitForBackground, hMat, _policy)
                    );
                _kernelSolutionPca->build(*(_templateMaskedImage->getImage()),
                                          *(_scienceMaskedImage->getImage()),
                                          *_varianceEstimate);
                if (checkConditionNumber) {
                    if (_kernelSolutionPca->getConditionNumber(ctype) > maxConditionNumber) {
                        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                                          "Candidate %d solution has bad condition number",
                                          this->getId());
                        this->setStatus(afwMath::SpatialCellCandidate::BAD);
                        return;
                    }
                }
                _kernelSolutionPca->solve();
            }
            else {
                _kernelSolutionOrig = boost::shared_ptr<StaticKernelSolution<PixelT> >(
                    new RegularizedKernelSolution<PixelT>(basisList, _fitForBackground, hMat, _policy)
                    );
                _kernelSolutionOrig->build(*(_templateMaskedImage->getImage()),
                                           *(_scienceMaskedImage->getImage()),
                                           *_varianceEstimate);
                if (checkConditionNumber) {
                    if (_kernelSolutionOrig->getConditionNumber(ctype) > maxConditionNumber) {
                        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                                          "Candidate %d solution has bad condition number",
                                          this->getId());
                        this->setStatus(afwMath::SpatialCellCandidate::BAD);
                        return;
                    }
                }
                _kernelSolutionOrig->solve();
            }
        }
        else {
            _useRegularization = false;
            pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate.build",
                              "Not using kernel regularization");
            if (_isInitialized) {
                _kernelSolutionPca = boost::shared_ptr<StaticKernelSolution<PixelT> >(
                    new StaticKernelSolution<PixelT>(basisList, _fitForBackground)
                    );
                _kernelSolutionPca->build(*(_templateMaskedImage->getImage()),
                                          *(_scienceMaskedImage->getImage()),
                                          *_varianceEstimate);
                if (checkConditionNumber) {
                    if (_kernelSolutionPca->getConditionNumber(ctype) > maxConditionNumber) {
                        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                                          "Candidate %d solution has bad condition number",
                                          this->getId());
                        this->setStatus(afwMath::SpatialCellCandidate::BAD);
                        return;
                    }
                }
                _kernelSolutionPca->solve();
            }
            else {
                _kernelSolutionOrig = boost::shared_ptr<StaticKernelSolution<PixelT> >(
                    new StaticKernelSolution<PixelT>(basisList, _fitForBackground)
                    );
                _kernelSolutionOrig->build(*(_templateMaskedImage->getImage()),
                                           *(_scienceMaskedImage->getImage()),
                                           *_varianceEstimate);
                if (checkConditionNumber) {
                    if (_kernelSolutionOrig->getConditionNumber(ctype) > maxConditionNumber) {
                        pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                                          "Candidate %d solution has bad condition number",
                                          this->getId());
                        this->setStatus(afwMath::SpatialCellCandidate::BAD);
                        return;
                    }
                }
                _kernelSolutionOrig->solve();
            }
        }
    }

template<typename PixelT >

void lsst::ip::diffim::KernelCandidate< PixelT >::build

(

afw::math::KernelList const &

basisList

)

Core functionality of KernelCandidate, to build and fill a KernelSolution.

Note

This is an expensive step involving matrix math, and one that may be called multiple times per candidate. Use cases are:

o _isInitialized = false. This is a constructed but not initialized KernelCandidate. When build() is called, M and B are derived from the MaskedImages and the basisList. KernelCandidate owns the knowledge of how to fill this KernelSolution; the solution knows how to solve itself and how to turn that into an output kernel. This solution ends up being _kernelSolution0.

o _isInitialized = true. This is for when build() is re-called using a different basis list, e.g. one based on Pca. We need to use M and B for the spatial modeling, but do not want to override the original KernelSolution. This solution ends up as _kernelSolutionCurrent. Build KernelSolution matrices for M x = B with regularization matrix H

Note

Modified equation is (Mt.M + lambda H) x = Mt.B with lambda a degree of freedom describing the "strength" of the regularization. The larger the value of lambda, the smoother the kernel, but the larger the residuals in the difference image.

A value of lambda = Trace(Mt.M) / Tr(H) will yield essentially equivalent power in the kernel smoothness and in the diffim quality. We scale this estimate by lambdaScaling to give more/less consideration to the smoothness of the kernel.

Definition at line 100 of file KernelCandidate.cc.

          {
        build(basisList, boost::shared_ptr<Eigen::MatrixXd>());
    }

template<typename PixelT >

void lsst::ip::diffim::KernelCandidate< PixelT >::build	(	afw::math::KernelList const &	basisList,
		boost::shared_ptr< Eigen::MatrixXd >	hMat
	)

Definition at line 107 of file KernelCandidate.cc.

          {

        /* Examine the policy for control over the variance estimate */
        afwImage::Image<afwImage::VariancePixel> var =
            afwImage::Image<afwImage::VariancePixel>(*(_scienceMaskedImage->getVariance()), true);
        /* Variance estimate comes from sum of image variances */
        var += (*(_templateMaskedImage->getVariance()));

        if (_policy.getBool("constantVarianceWeighting")) {
            /* Constant variance weighting */
            afwMath::Statistics varStats = afwMath::makeStatistics(var, afwMath::MEDIAN);
            float varValue;
            if (varStats.getValue(afwMath::MEDIAN) <= 0.0)
                varValue = 1.0;
            else
                varValue = varStats.getValue(afwMath::MEDIAN);
            pexLog::TTrace<5>("lsst.ip.diffim.KernelCandidate",
                              "Candidate %d using constant variance of %.2f", this->getId(), varValue);
            var = varValue;

        }

        _varianceEstimate = VariancePtr( new afwImage::Image<afwImage::VariancePixel>(var) );

        try {
            _buildKernelSolution(basisList, hMat);
        } catch (pexExcept::Exception &e) {
            throw e;
        }

        if (_policy.getBool("iterateSingleKernel") && (!(_policy.getBool("constantVarianceWeighting")))) {
            afwImage::MaskedImage<PixelT> diffim = getDifferenceImage(KernelCandidate::RECENT);
            _varianceEstimate = diffim.getVariance();

            try {
                _buildKernelSolution(basisList, hMat);
            } catch (pexExcept::Exception &e) {
                throw e;
            }
        }

        _isInitialized = true;

    }

template<typename PixelT >

double lsst::ip::diffim::KernelCandidate< PixelT >::getBackground

(

CandidateSwitch

cand

)

const

Definition at line 287 of file KernelCandidate.cc.

                                                                            {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getBackground();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getBackground();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get background");
        }
    }

template<typename _PixelT>

double lsst::ip::diffim::KernelCandidate< _PixelT >::getCandidateRating ( ) const

inlinevirtual

Return Candidate rating.

Note

Required method for use by SpatialCell; e.g. total flux

Implements lsst.afw.math::SpatialCellCandidate.

Definition at line 95 of file KernelCandidate.h.

{ return _coreFlux; }

template<typename PixelT >

lsst::afw::image::MaskedImage< PixelT > lsst::ip::diffim::KernelCandidate< PixelT >::getDifferenceImage

(

CandidateSwitch

cand

)

Calculate associated difference image using internal solutions.

Definition at line 402 of file KernelCandidate.cc.

                              {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return getDifferenceImage(_kernelSolutionOrig->getKernel(),
                                          _kernelSolutionOrig->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return getDifferenceImage(_kernelSolutionPca->getKernel(),
                                          _kernelSolutionPca->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return getDifferenceImage(_kernelSolutionPca->getKernel(),
                                          _kernelSolutionPca->getBackground());
            else if (_kernelSolutionOrig)
                return getDifferenceImage(_kernelSolutionOrig->getKernel(),
                                          _kernelSolutionOrig->getBackground());
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get diffim");
        }
    }

template<typename PixelT >

lsst::afw::image::MaskedImage< PixelT > lsst::ip::diffim::KernelCandidate< PixelT >::getDifferenceImage	(	afw::math::Kernel::Ptr	kernel,
		double	background
	)

Calculate associated difference image using input kernel and background.

Note

Useful for spatial modeling

Definition at line 434 of file KernelCandidate.cc.

          {
        /* Make diffim and set chi2 from result */
        afwImage::MaskedImage<PixelT> diffIm = convolveAndSubtract(*_templateMaskedImage,
                                                                   *_scienceMaskedImage,
                                                                   *kernel,
                                                                   background);
        return diffIm;
    }

template<typename PixelT >

KernelCandidate< PixelT >::ImageT::ConstPtr lsst::ip::diffim::KernelCandidate< PixelT >::getImage ( ) const

virtual

Return the Candidate's Image.

Implements lsst.afw.math::SpatialCellImageCandidate< afw::math::Kernel::Pixel >.

Definition at line 369 of file KernelCandidate.cc.

                                                                                  {
        return getKernelImage(KernelCandidate::ORIG);
    }

template<typename PixelT >

lsst::afw::math::Kernel::Ptr lsst::ip::diffim::KernelCandidate< PixelT >::getKernel

(

CandidateSwitch

cand

)

const

Return results of kernel solution.

Definition at line 260 of file KernelCandidate.cc.

                                                                                      {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKernel();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKernel();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get kernel");
        }
    }

template<typename PixelT >

KernelCandidate< PixelT >::ImageT::Ptr lsst::ip::diffim::KernelCandidate< PixelT >::getKernelImage

(

CandidateSwitch

cand

)

const

Definition at line 341 of file KernelCandidate.cc.

                                    {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->makeKernelImage();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->makeKernelImage();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get kernel image");
        }
    }

template<typename PixelT >

boost::shared_ptr< StaticKernelSolution< PixelT > > lsst::ip::diffim::KernelCandidate< PixelT >::getKernelSolution

(

CandidateSwitch

cand

)

const

Definition at line 374 of file KernelCandidate.cc.

                                    {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig;
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca;
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca;
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig;
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get solution");
        }
    }

template<typename PixelT >

double lsst::ip::diffim::KernelCandidate< PixelT >::getKsum

(

CandidateSwitch

cand

)

const

Definition at line 314 of file KernelCandidate.cc.

                                                                      {
        if (cand == KernelCandidate::ORIG) {
            if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Original kernel does not exist");
        }
        else if (cand == KernelCandidate::PCA) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "Pca kernel does not exist");
        }
        else if (cand == KernelCandidate::RECENT) {
            if (_kernelSolutionPca)
                return _kernelSolutionPca->getKsum();
            else if (_kernelSolutionOrig)
                return _kernelSolutionOrig->getKsum();
            else
                throw LSST_EXCEPT(pexExcept::Exception, "No kernels exist");
        }
        else {
            throw LSST_EXCEPT(pexExcept::Exception, "Invalid CandidateSwitch, cannot get kSum");
        }
    }

template<typename _PixelT>

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getScienceMaskedImage ( )

inline

Definition at line 104 of file KernelCandidate.h.

{return _scienceMaskedImage;}

template<typename _PixelT>

SourcePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getSource ( ) const

inline

Return the original source.

Definition at line 99 of file KernelCandidate.h.

{ return _source; }

template<typename _PixelT>

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::getTemplateMaskedImage ( )

inline

Return pointers to the image pixels used in kernel determination.

Definition at line 103 of file KernelCandidate.h.

{return _templateMaskedImage;}

template<typename _PixelT>

bool lsst::ip::diffim::KernelCandidate< _PixelT >::isInitialized ( ) const

inline

Definition at line 132 of file KernelCandidate.h.

{return _isInitialized;}

Member Data Documentation

template<typename _PixelT>

double lsst::ip::diffim::KernelCandidate< _PixelT >::_coreFlux

private

Mean S/N in the science image.

Definition at line 195 of file KernelCandidate.h.

template<typename _PixelT>

bool lsst::ip::diffim::KernelCandidate< _PixelT >::_fitForBackground

private

Definition at line 198 of file KernelCandidate.h.

template<typename _PixelT>

bool lsst::ip::diffim::KernelCandidate< _PixelT >::_isInitialized

private

Has the kernel been built.

Definition at line 196 of file KernelCandidate.h.

template<typename _PixelT>

boost::shared_ptr<StaticKernelSolution<PixelT> > lsst::ip::diffim::KernelCandidate< _PixelT >::_kernelSolutionOrig

private

Original basis solution.

Definition at line 201 of file KernelCandidate.h.

template<typename _PixelT>

boost::shared_ptr<StaticKernelSolution<PixelT> > lsst::ip::diffim::KernelCandidate< _PixelT >::_kernelSolutionPca

private

Most recent solution.

Definition at line 204 of file KernelCandidate.h.

template<typename _PixelT>

pex::policy::Policy lsst::ip::diffim::KernelCandidate< _PixelT >::_policy

private

Policy.

Definition at line 193 of file KernelCandidate.h.

template<typename _PixelT>

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::_scienceMaskedImage

private

Subimage around which you build kernel.

Definition at line 191 of file KernelCandidate.h.

template<typename _PixelT>

SourcePtr lsst::ip::diffim::KernelCandidate< _PixelT >::_source

private

Definition at line 194 of file KernelCandidate.h.

template<typename _PixelT>

MaskedImagePtr lsst::ip::diffim::KernelCandidate< _PixelT >::_templateMaskedImage

private

Subimage around which you build kernel.

Definition at line 190 of file KernelCandidate.h.

template<typename _PixelT>

bool lsst::ip::diffim::KernelCandidate< _PixelT >::_useRegularization

private

Use regularization?

Definition at line 197 of file KernelCandidate.h.

template<typename _PixelT>

VariancePtr lsst::ip::diffim::KernelCandidate< _PixelT >::_varianceEstimate

private

Estimate of the local variance.

Definition at line 192 of file KernelCandidate.h.

---

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

• /home/lsstsw/stack/Linux64/ip_diffim/10.0-5-gca2295e+25/include/lsst/ip/diffim/KernelCandidate.h
• /home/lsstsw/stack/Linux64/ip_diffim/10.0-5-gca2295e+25/src/KernelCandidate.cc