lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT > Class Template Reference

Builds the convolution kernel for a given candidate. More...

#include <BuildSingleKernelVisitor.h>

Inheritance diagram for lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >:

Public Types
typedef std::shared_ptr< BuildSingleKernelVisitor< PixelT > >	Ptr

Public Member Functions
	BuildSingleKernelVisitor (lsst::afw::math::KernelList const &basisList, lsst::daf::base::PropertySet const &ps)
	BuildSingleKernelVisitor (lsst::afw::math::KernelList const &basisList, lsst::daf::base::PropertySet const &ps, Eigen::MatrixXd const &hMat)
virtual	~BuildSingleKernelVisitor ()
void	setSkipBuilt (bool skip)
int	getNRejected ()
int	getNProcessed ()
void	reset ()
void	processCandidate (lsst::afw::math::SpatialCellCandidate *candidate)

Detailed Description

template<typename PixelT>
class lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >

Builds the convolution kernel for a given candidate.

std::shared_ptr<PropertySet> ps(new PropertySet);
ps->set("constantVarianceWeighting", false);
ps->set("iterateSingleKernel", false);
ps->set("singleKernelClipping", true);
ps->set("candidateResidualMeanMax", 0.25);
ps->set("candidateResidualStdMax", 1.25);
 
detail::BuildSingleKernelVisitor<PixelT> singleKernelFitter(*ps);
int nRejected = -1;
while (nRejected != 0) {
    singleKernelFitter.reset();
    kernelCells.visitCandidates(&singleKernelFitter, nStarPerCell);
    nRejected = singleKernelFitter.getNRejected();
}

Note

Visits each current candidate in a afwMath::SpatialCellSet, and builds its kernel using its build() method. We don't build the kernel for every candidate since this is computationally expensive, only when its the current candidate in the cell. During the course of building the kernel, it also assesses the quality of the difference image. If it is determined to be bad (based on the PropertySet paramters) the candidate is flagged as afwMath::SpatialCellCandidate::BAD; otherwise its marked as afwMath::SpatialCellCandidate::GOOD. Keeps a running sample of all the new candidates it visited that turned out to be bad.

Because this visitor does not have access to the next candidate in the cell, it must be called iteratively until no candidates are rejected. This ensures that the current candidate of every cell has an initialized Kernel. This also requires that this class re-Visit all the cells after any other Visitors with the ability to mark something as BAD.

Because we are frequently re-Visiting entirely GOOD candidates during these iterations, the option of _skipBuilt=true will enable the user to not rebuilt the kernel on every visit.

For the particular use case of creating a Pca basis from the raw kernels, we want to re-Visit each candidate and re-fit the kernel using this Pca basis. This requires the user to setSkipBuilt(false) so that the candidate is reprocessed with this new basis.

Definition at line 30 of file BuildSingleKernelVisitor.h.

Member Typedef Documentation

Ptr

template<typename PixelT >

typedef std::shared_ptr<BuildSingleKernelVisitor<PixelT> > lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::Ptr

Definition at line 33 of file BuildSingleKernelVisitor.h.

Constructor & Destructor Documentation

BuildSingleKernelVisitor() [1/2]

template<typename PixelT >

lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::BuildSingleKernelVisitor	(	lsst::afw::math::KernelList const &	basisList,
		lsst::daf::base::PropertySet const &	ps )

Parameters

basisList	List of basis kernels for resulting LinearCombinationKernel
ps	ps file directing behavior

Definition at line 88 of file BuildSingleKernelVisitor.cc.

          :
        afwMath::CandidateVisitor(),
        _basisList(basisList),
        _ps(ps.deepCopy()),
        _hMat(),
        _imstats(ImageStatistics<PixelT>(ps)),
        _skipBuilt(true),
        _nRejected(0),
        _nProcessed(0),
        _useRegularization(false),
        _useCoreStats(ps.getAsBool("useCoreStats")),
        _coreRadius(ps.getAsInt("candidateCoreRadius"))
    {};

BuildSingleKernelVisitor() [2/2]

template<typename PixelT >

lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::BuildSingleKernelVisitor	(	lsst::afw::math::KernelList const &	basisList,
		lsst::daf::base::PropertySet const &	ps,
		Eigen::MatrixXd const &	hMat )

Parameters

basisList	List of basis kernels for resulting LinearCombinationKernel
ps	ps file directing behavior
hMat	Regularization matrix

Definition at line 107 of file BuildSingleKernelVisitor.cc.

          :
        afwMath::CandidateVisitor(),
        _basisList(basisList),
        _ps(ps.deepCopy()),
        _hMat(hMat),
        _imstats(ImageStatistics<PixelT>(ps)),
        _skipBuilt(true),
        _nRejected(0),
        _nProcessed(0),
        _useRegularization(true),
        _useCoreStats(ps.getAsBool("useCoreStats")),
        _coreRadius(ps.getAsInt("candidateCoreRadius"))
    {};

~BuildSingleKernelVisitor()

template<typename PixelT >

virtual lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::~BuildSingleKernelVisitor ( )

inlinevirtual

Definition at line 44 of file BuildSingleKernelVisitor.h.

{};

Member Function Documentation

getNProcessed()

template<typename PixelT >

int lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::getNProcessed ( )

inline

Definition at line 56 of file BuildSingleKernelVisitor.h.

{return _nProcessed;}

getNRejected()

template<typename PixelT >

int lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::getNRejected ( )

inline

Definition at line 55 of file BuildSingleKernelVisitor.h.

{return _nRejected;}

processCandidate()

template<typename PixelT >

void lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::processCandidate ( lsst::afw::math::SpatialCellCandidate * candidate )

virtual

Reimplemented from lsst::afw::math::CandidateVisitor.

Definition at line 128 of file BuildSingleKernelVisitor.cc.

          {
 
        ipDiffim::KernelCandidate<PixelT> *kCandidate =
            dynamic_cast<ipDiffim::KernelCandidate<PixelT> *>(candidate);
        if (kCandidate == NULL) {
            LOGL_DEBUG("TRACE2.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Failed to cast SpatialCellCandidate to KernelCandidate %d",
                       kCandidate->getId());
            throw LSST_EXCEPT(pexExcept::LogicError,
                              "Failed to cast SpatialCellCandidate to KernelCandidate");
        }
 
        if (_skipBuilt and kCandidate->isInitialized()) {
            return;
        }
 
        LOGL_DEBUG("TRACE1.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "Processing candidate %d", kCandidate->getId());
        LOGL_DEBUG("TRACE4.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "X = %.2f Y = %.2f",
                   kCandidate->getXCenter(),
                   kCandidate->getYCenter());
 
        /* Build its kernel here */
        try {
            if (_useRegularization)
                kCandidate->build(_basisList, _hMat);
            else
                kCandidate->build(_basisList);
 
        } catch (pexExcept::Exception &e) {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Unable to process candidate %d; exception caught (%s)",
                       kCandidate->getId(),
                       e.what());
            _nRejected += 1;
            return;
        }
 
        if (kCandidate->getStatus() == afwMath::SpatialCellCandidate::BAD) {
            LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Candidate %d Returned BAD upon build, exiting",
                       kCandidate->getId());
            _nRejected += 1;
            return;
        }
 
 
         /*
         * Make diffim and set chi2 from result.  Note that you need to use the
         * most recent kernel
         */
        MaskedImageT diffim = kCandidate->getDifferenceImage(ipDiffim::KernelCandidate<PixelT>::RECENT);
        try {
            if (_useCoreStats)
                _imstats.apply(diffim, _coreRadius);
            else
                _imstats.apply(diffim);
        } catch (pexExcept::Exception& e) {
            LOGL_DEBUG("TRACE2.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Unable to calculate imstats for Candidate %d", kCandidate->getId());
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            return;
        }
        _nProcessed += 1;
 
        kCandidate->setChi2(_imstats.getVariance());
 
        /* When using a Pca basis, we don't reset the kernel or background,
           so we need to evaluate these locally for the Trace */
        double kSum = kCandidate->getKsum(ipDiffim::KernelCandidate<PixelT>::RECENT);
        double background = kCandidate->getBackground(ipDiffim::KernelCandidate<PixelT>::RECENT);
 
        LOGL_DEBUG("TRACE4.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "Chi2 = %.3f", kCandidate->getChi2());
        LOGL_DEBUG("TRACE4.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "Kernel Sum = %.3f", kSum);
        LOGL_DEBUG("TRACE4.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "Background = %.3f", background);
        LOGL_DEBUG("TRACE2.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                   "Candidate %d resids = %.3f +/- %.3f sigma (%d pix)",
                   kCandidate->getId(),
                   _imstats.getMean(),
                   _imstats.getRms(),
                   _imstats.getNpix());
 
        bool meanIsNan = std::isnan(_imstats.getMean());
        bool rmsIsNan  = std::isnan(_imstats.getRms());
        if (meanIsNan || rmsIsNan) {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
            LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Rejecting candidate %d, encountered NaN",
                       kCandidate->getId());
            _nRejected += 1;
            return;
        }
 
        if (_ps->getAsBool("singleKernelClipping")) {
            if (fabs(_imstats.getMean()) > _ps->getAsDouble("candidateResidualMeanMax")) {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                           "Rejecting candidate %d; bad mean residual : |%.3f| > %.3f",
                           kCandidate->getId(),
                           _imstats.getMean(),
                           _ps->getAsDouble("candidateResidualMeanMax"));
                _nRejected += 1;
            }
            else if (_imstats.getRms() > _ps->getAsDouble("candidateResidualStdMax")) {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                           "Rejecting candidate %d; bad residual rms : %.3f > %.3f",
                           kCandidate->getId(),
                           _imstats.getRms(),
                           _ps->getAsDouble("candidateResidualStdMax"));
                _nRejected += 1;
            }
            else {
                kCandidate->setStatus(afwMath::SpatialCellCandidate::GOOD);
                LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                           "Source kernel OK");
            }
        }
        else {
            kCandidate->setStatus(afwMath::SpatialCellCandidate::GOOD);
            LOGL_DEBUG("TRACE5.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Sigma clipping not enabled");
        }
 
        /* Core resids for debugging */
        if (!(_useCoreStats)) {
            try {
                _imstats.apply(diffim, _coreRadius);
            } catch (pexExcept::Exception& e) {
                LOGL_DEBUG("TRACE2.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                           "Unable to calculate core imstats for Candidate %d",
                           kCandidate->getId());
                kCandidate->setStatus(afwMath::SpatialCellCandidate::BAD);
                return;
            }
            LOGL_DEBUG("TRACE3.ip.diffim.BuildSingleKernelVisitor.processCandidate",
                       "Candidate %d core resids = %.3f +/- %.3f sigma (%d pix)",
                       kCandidate->getId(),
                       _imstats.getMean(),
                       _imstats.getRms(),
                       _imstats.getNpix());
        }
 
    }

reset()

template<typename PixelT >

void lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::reset ( )

inlinevirtual

Reimplemented from lsst::afw::math::CandidateVisitor.

Definition at line 57 of file BuildSingleKernelVisitor.h.

{_nRejected = 0; _nProcessed = 0;}

setSkipBuilt()

template<typename PixelT >

void lsst::ip::diffim::detail::BuildSingleKernelVisitor< PixelT >::setSkipBuilt ( bool skip )

inline

Definition at line 53 of file BuildSingleKernelVisitor.h.

{_skipBuilt = skip;}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g1470d8bcf6+3ea6592b6f/include/lsst/ip/diffim/BuildSingleKernelVisitor.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/ip_diffim/g1470d8bcf6+3ea6592b6f/src/BuildSingleKernelVisitor.cc