lsst::meas::modelfit Namespace Reference

Namespaces
namespace	cmodel
namespace	common
namespace	detail
namespace	optimizer
namespace	pixelFitRegion
namespace	priors
namespace	psf
namespace	version

Classes
class	AdaptiveImportanceSampler
	Sampler class that performs Monte Carlo sampling, while iteratively updating the analytic distribution from which points are drawn. More...
class	CModelAlgorithm
	Main public interface class for CModel algorithm. More...
struct	CModelControl
	The main control object for CModel, containing parameters for the final linear fit and aggregating the other control objects. More...
struct	CModelResult
	Master result object for CModel, containing results for the final linear fit and three nested CModelStageResult objects for the results of the previous stages. More...
struct	CModelStageControl
	Nested control object for CModel that configures one of the three ("initial", "exp", "dev") nonlinear fitting stages. More...
struct	CModelStageResult
	Result object for a single nonlinear fitting stage of the CModel algorithm. More...
class	DoubleShapeletPsfApproxAlgorithm
	An algorithm that fits a 2-component shapelet approximation to the PSF model. More...
class	DoubleShapeletPsfApproxControl
	Control object used to configure a 2-shapelet fit to a PSF model; see DoubleShapeletPsfApproxAlgorithm. More...
class	EpochFootprint
	An image at one epoch of a galaxy, plus associated info. More...
class	GeneralPsfFitter
	Class for fitting multishapelet models to PSF images. More...
class	GeneralPsfFitterAlgorithm
class	GeneralPsfFitterComponentControl
	Control object used to define one piece of multishapelet fit to a PSF model; see GeneralPsfFitterControl. More...
class	GeneralPsfFitterControl
	Control object used to configure a multishapelet fit to a PSF model; see GeneralPsfFitter. More...
class	ImportanceSamplerControl
	Control object for one iteration of adaptive importance sampling. More...
class	Likelihood
	Base class for optimizer/sampler likelihood functions that compute likelihood at a point. More...
struct	LocalUnitTransform
	A local mapping between two UnitSystems. More...
class	Mixture
class	MixtureComponent
	A weighted Student's T or Gaussian distribution used as a component in a Mixture. More...
class	MixturePrior
	A prior that's flat in amplitude parameters, and uses a Mixture for nonlinear parameters. More...
class	MixtureUpdateRestriction
	Helper class used to define restrictions to the form of the component parameters in Mixture::updateEM. More...
class	Model
	Abstract base class and concrete factories that define multi-shapelet galaxy models. More...
class	MultiModel
	A concrete Model class that simply concatenates several other Models. More...
class	MultiShapeletPsfLikelihood
	Likelihood object used to fit multishapelet models to PSF model images; mostly for internal use by GeneralPsfFitter. More...
class	Optimizer
	A numerical optimizer customized for least-squares problems with Bayesian priors. More...
class	OptimizerControl
	Configuration object for Optimizer. More...
class	OptimizerHistoryRecorder
class	OptimizerObjective
	Base class for objective functions for Optimizer. More...
class	PixelFitRegion
struct	PixelFitRegionControl
class	Prior
	Base class for Bayesian priors. More...
class	Sampler
class	SamplingObjective
class	SemiEmpiricalPrior
	A piecewise prior motivated by both real distributions and practical considerations. More...
struct	SemiEmpiricalPriorControl
class	SoftenedLinearPrior
	A prior that's linear in radius and flat in ellipticity, with a cubic roll-off at the edges. More...
struct	SoftenedLinearPriorControl
class	TruncatedGaussian
	Represents a multidimensional Gaussian function truncated at zero. More...
class	TruncatedGaussianEvaluator
	Helper class for evaluating the -log of a TruncatedGaussian. More...
class	TruncatedGaussianLogEvaluator
	Helper class for evaluating the -log of a TruncatedGaussian. More...
class	TruncatedGaussianSampler
	Helper class for drawing samples from a TruncatedGaussian. More...
struct	UnitSystem
	A simple struct that combines a Wcs and a PhotoCalib. More...
class	UnitTransformedLikelihood
	A concrete Likelihood class that does not require its parameters and data to be in the same UnitSystem. More...
class	UnitTransformedLikelihoodControl
	Control object used to initialize a UnitTransformedLikelihood. More...

Typedefs
typedef float	Pixel
	Typedefs to be used for pixel values.
typedef double	Scalar
	Typedefs to be used for probability and parameter values.
typedef Eigen::Matrix< Scalar, Eigen::Dynamic, Eigen::Dynamic >	Matrix
typedef Eigen::Matrix< Scalar, Eigen::Dynamic, 1 >	Vector
typedef afw::table::Key< Scalar >	ScalarKey
typedef afw::table::Key< afw::table::Array< Scalar > >	ArrayKey
typedef std::vector< std::shared_ptr< Model > >	ModelVector
using	PyImportanceSamplerControl = py::class_< ImportanceSamplerControl, std::shared_ptr< ImportanceSamplerControl > >
using	PyAdaptiveImportanceSampler = py::class_< AdaptiveImportanceSampler, std::shared_ptr< AdaptiveImportanceSampler >, Sampler >
using	PyLikelihood = py::class_< Likelihood, std::shared_ptr< Likelihood > >
using	PyModel = py::class_< Model, std::shared_ptr< Model > >
using	PyMultiModel = py::class_< MultiModel, std::shared_ptr< MultiModel >, Model >
using	PyPixelFitRegionControl = py::class_< PixelFitRegionControl, std::shared_ptr< PixelFitRegionControl > >
using	PyPixelFitRegion = py::class_< PixelFitRegion, std::shared_ptr< PixelFitRegion > >
using	PySamplingObjective = py::class_< SamplingObjective, std::shared_ptr< SamplingObjective > >
using	PySampler = py::class_< Sampler, std::shared_ptr< Sampler > >
using	PyUnitSystem = py::class_< UnitSystem, std::shared_ptr< UnitSystem > >
using	PyLocalUnitTransform = py::class_< LocalUnitTransform, std::shared_ptr< LocalUnitTransform > >
using	PyUnitTransformedLikelihoodControl = py::class_< UnitTransformedLikelihoodControl, std::shared_ptr< UnitTransformedLikelihoodControl > >
using	PyEpochFootprint = py::class_< EpochFootprint, std::shared_ptr< EpochFootprint > >
using	PyUnitTransformedLikelihood = py::class_< UnitTransformedLikelihood, std::shared_ptr< UnitTransformedLikelihood >, Likelihood >

Functions
void	solveTrustRegion (ndarray::Array< Scalar, 1, 1 > const &x, ndarray::Array< Scalar const, 2, 1 > const &F, ndarray::Array< Scalar const, 1, 1 > const &g, double r, double tolerance)
	Solve a symmetric quadratic matrix equation with a ball constraint.
void	wrapAdaptiveImportanceSampler (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapCmodel (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapIntegrals (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapLikelihood (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapMixture (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapModel (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapMultiModel (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapOptimizer (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapPixelFitRegion (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapPriors (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapPsf (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapSampler (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapTruncatedGaussian (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapUnitSystem (lsst::cpputils::python::WrapperCollection &wrappers)
void	wrapUnitTransformedLikelihood (lsst::cpputils::python::WrapperCollection &wrappers)
	PYBIND11_MODULE (_modelfitLib, mod)

Typedef Documentation

ArrayKey

typedef afw::table::Key< afw::table::Array<Scalar> > lsst::meas::modelfit::ArrayKey

Definition at line 48 of file common.h.

Matrix

typedef Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic> lsst::meas::modelfit::Matrix

Definition at line 45 of file common.h.

ModelVector

typedef std::vector<std::shared_ptr<Model> > lsst::meas::modelfit::ModelVector

Definition at line 41 of file Model.h.

Pixel

typedef float lsst::meas::modelfit::Pixel

Typedefs to be used for pixel values.

Definition at line 37 of file common.h.

PyAdaptiveImportanceSampler

using lsst::meas::modelfit::PyAdaptiveImportanceSampler = typedef py::class_<AdaptiveImportanceSampler, std::shared_ptr<AdaptiveImportanceSampler>, Sampler>

Definition at line 42 of file adaptiveImportanceSampler.cc.

PyEpochFootprint

using lsst::meas::modelfit::PyEpochFootprint = typedef py::class_<EpochFootprint, std::shared_ptr<EpochFootprint> >

Definition at line 43 of file unitTransformedLikelihood.cc.

PyImportanceSamplerControl

using lsst::meas::modelfit::PyImportanceSamplerControl = typedef py::class_<ImportanceSamplerControl, std::shared_ptr<ImportanceSamplerControl> >

Definition at line 40 of file adaptiveImportanceSampler.cc.

PyLikelihood

using lsst::meas::modelfit::PyLikelihood = typedef py::class_<Likelihood, std::shared_ptr<Likelihood> >

Definition at line 38 of file likelihood.cc.

PyLocalUnitTransform

using lsst::meas::modelfit::PyLocalUnitTransform = typedef py::class_<LocalUnitTransform, std::shared_ptr<LocalUnitTransform> >

Definition at line 37 of file unitSystem.cc.

PyModel

using lsst::meas::modelfit::PyModel = typedef py::class_<Model, std::shared_ptr<Model> >

Definition at line 41 of file model.cc.

PyMultiModel

using lsst::meas::modelfit::PyMultiModel = typedef py::class_<MultiModel, std::shared_ptr<MultiModel>, Model>

Definition at line 37 of file multiModel.cc.

PyPixelFitRegion

using lsst::meas::modelfit::PyPixelFitRegion = typedef py::class_<PixelFitRegion, std::shared_ptr<PixelFitRegion> >

Definition at line 40 of file pixelFitRegion.cc.

PyPixelFitRegionControl

using lsst::meas::modelfit::PyPixelFitRegionControl = typedef py::class_<PixelFitRegionControl, std::shared_ptr<PixelFitRegionControl> >

Definition at line 39 of file pixelFitRegion.cc.

PySampler

using lsst::meas::modelfit::PySampler = typedef py::class_<Sampler, std::shared_ptr<Sampler> >

Definition at line 42 of file sampler.cc.

PySamplingObjective

using lsst::meas::modelfit::PySamplingObjective = typedef py::class_<SamplingObjective, std::shared_ptr<SamplingObjective> >

Definition at line 41 of file sampler.cc.

PyUnitSystem

using lsst::meas::modelfit::PyUnitSystem = typedef py::class_<UnitSystem, std::shared_ptr<UnitSystem> >

Definition at line 36 of file unitSystem.cc.

PyUnitTransformedLikelihood

using lsst::meas::modelfit::PyUnitTransformedLikelihood = typedef py::class_<UnitTransformedLikelihood, std::shared_ptr<UnitTransformedLikelihood>, Likelihood>

Definition at line 45 of file unitTransformedLikelihood.cc.

PyUnitTransformedLikelihoodControl

using lsst::meas::modelfit::PyUnitTransformedLikelihoodControl = typedef py::class_<UnitTransformedLikelihoodControl, std::shared_ptr<UnitTransformedLikelihoodControl> >

Definition at line 40 of file unitTransformedLikelihood.cc.

Scalar

typedef double lsst::meas::modelfit::Scalar

Typedefs to be used for probability and parameter values.

Definition at line 44 of file common.h.

ScalarKey

typedef afw::table::Key<Scalar> lsst::meas::modelfit::ScalarKey

Definition at line 47 of file common.h.

Vector

typedef Eigen::Matrix<Scalar,Eigen::Dynamic,1> lsst::meas::modelfit::Vector

Definition at line 46 of file common.h.

Function Documentation

PYBIND11_MODULE()

lsst::meas::modelfit::PYBIND11_MODULE	(	_modelfitLib	,
		mod
	)

Definition at line 51 of file _modelfitLib.cc.

                                   {
    lsst::utils::python::WrapperCollection wrappers(mod, "lsst.meas.modelfit");
 
    wrappers.addInheritanceDependency("lsst.meas.base");
 
    wrappers.addSignatureDependency("lsst.afw.detection");
    wrappers.addSignatureDependency("lsst.afw.image");
    wrappers.addSignatureDependency("lsst.afw.math");
    wrappers.addSignatureDependency("lsst.afw.geom.ellipses");
    wrappers.addSignatureDependency("lsst.afw.table");
    wrappers.addSignatureDependency("lsst.shapelet");
 
    wrapPriors(wrappers);
    wrapUnitSystem(wrappers);
    wrapModel(wrappers);
    wrapLikelihood(wrappers);
    wrapMixture(wrappers);
    wrapOptimizer(wrappers);
    wrapSampler(wrappers);
    wrapPixelFitRegion(wrappers);
 
    wrapAdaptiveImportanceSampler(wrappers);
    wrapCmodel(wrappers);
    wrapIntegrals(wrappers);
    wrapMultiModel(wrappers);
    wrapPsf(wrappers);
    wrapTruncatedGaussian(wrappers);
    wrapUnitTransformedLikelihood(wrappers);
    wrappers.finish();
}

solveTrustRegion()

void lsst::meas::modelfit::solveTrustRegion	(	ndarray::Array< Scalar, 1, 1 > const &	x,
		ndarray::Array< Scalar const, 2, 1 > const &	F,
		ndarray::Array< Scalar const, 1, 1 > const &	g,
		double	r,
		double	tolerance
	)

Solve a symmetric quadratic matrix equation with a ball constraint.

This computes a near-exact solution to the "trust region subproblem" necessary in trust-region-based nonlinear optimizers:

\[ \min_x{\quad g^T x + \frac{1}{2}x^T F x}\quad\quad\quad \text{s.t.} ||x|| \le r \]

The tolerance parameter sets how close to \(r\) we require the norm of the solution to be when it lies on the constraint, as a fraction of \(r\) itself.

This implementation is based on the algorithm described in Section 4.3 of "Nonlinear Optimization" by Nocedal and Wright.

wrapAdaptiveImportanceSampler()

void lsst::meas::modelfit::wrapAdaptiveImportanceSampler

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 45 of file adaptiveImportanceSampler.cc.

                                                                                  {
    wrappers.wrapType(PyImportanceSamplerControl(wrappers.module, "ImportanceSamplerControl"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, nSamples);
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, nUpdateSteps);
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, tau1);
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, tau2);
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, targetPerplexity);
        LSST_DECLARE_CONTROL_FIELD(cls, ImportanceSamplerControl, maxRepeat);
 
        PyAdaptiveImportanceSampler clsAdaptiveImportanceSampler(mod, "AdaptiveImportanceSampler");
        clsAdaptiveImportanceSampler.def(py::init<afw::table::Schema &, std::shared_ptr<afw::math::Random>,
                                                 std::map<int, ImportanceSamplerControl> const &, bool>(),
                                         "sampleSchema"_a, "rng"_a, "ctrls"_a, "doSaveIteration"_a = false);
        // virtual run method already wrapped by Sampler base class
        clsAdaptiveImportanceSampler.def("computeNormalizedPerplexity",
                                         &AdaptiveImportanceSampler::computeNormalizedPerplexity);
        clsAdaptiveImportanceSampler.def("computeEffectiveSampleSizeFraction",
                                         &AdaptiveImportanceSampler::computeEffectiveSampleSizeFraction);
    });
}

wrapCmodel()

void lsst::meas::modelfit::wrapCmodel

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 205 of file cmodel.cc.

                                                               {
    declareCModelStageControl(wrappers);
    auto clsControl = declareCModelControl(wrappers);
    declareCModelStageResult(wrappers);
    auto clsResult = declareCModelResult(wrappers);
    auto clsAlgorithm = declareCModelAlgorithm(wrappers);
    clsAlgorithm.attr("Control") = clsControl;
    clsAlgorithm.attr("Result") = clsResult;
}

wrapIntegrals()

void lsst::meas::modelfit::wrapIntegrals

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 36 of file integrals.cc.

                                                                  {
    wrappers.module.def("phid", &detail::phid);
    wrappers.module.def("bvnu", &detail::bvnu);
}

wrapLikelihood()

void lsst::meas::modelfit::wrapLikelihood

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 40 of file likelihood.cc.

                                                                   {
    // py::module::import("lsst.meas.modelfit.model");
    wrappers.wrapType(PyLikelihood(wrappers.module, "Likelihood"), [](auto &mod, auto &cls) {
        cls.def("getDataDim", &Likelihood::getDataDim);
        cls.def("getAmplitudeDim", &Likelihood::getAmplitudeDim);
        cls.def("getNonlinearDim", &Likelihood::getNonlinearDim);
        cls.def("getFixedDim", &Likelihood::getFixedDim);
        cls.def("getFixed", &Likelihood::getFixed);
        cls.def("getData", &Likelihood::getData);
        cls.def("getUnweightedData", &Likelihood::getUnweightedData);
        cls.def("getWeights", &Likelihood::getWeights);
        cls.def("getVariance", &Likelihood::getVariance);
        cls.def("getModel", &Likelihood::getModel);
        cls.def("computeModelMatrix", &Likelihood::computeModelMatrix, "modelMatrix"_a, "nonlinear"_a,
                "doApplyWeights"_a = true);
    });
}

wrapMixture()

void lsst::meas::modelfit::wrapMixture

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 143 of file mixture.cc.

                                                                {
    auto clsMixtureComponent = declareMixtureComponent(wrappers);
    auto clsMixtureUpdateRestriction = declareMixtureUpdateRestriction(wrappers);
    auto clsMixture = declareMixture(wrappers);
    clsMixture.attr("Component") = clsMixtureComponent;
    clsMixture.attr("UpdateRestriction") = clsMixtureUpdateRestriction;
}

wrapModel()

void lsst::meas::modelfit::wrapModel

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 43 of file model.cc.

                                                              {
    wrappers.wrapType(PyModel(wrappers.module, "Model"), [](auto &mod, auto &cls) {
        py::enum_<Model::CenterEnum>(cls, "CenterEnum")
                .value("FIXED_CENTER", Model::FIXED_CENTER)
                .value("SINGLE_CENTER", Model::SINGLE_CENTER)
                .value("MULTI_CENTER", Model::MULTI_CENTER)
                .export_values();
 
        cls.def_static("make", (std::shared_ptr<Model>(*)(Model::BasisVector, Model::NameVector const &,
                                                          Model::CenterEnum)) &
                               Model::make,
                       "basisVector"_a, "prefixes"_a, "center"_a);
        cls.def_static("make", (std::shared_ptr<Model>(*)(std::shared_ptr<shapelet::MultiShapeletBasis>,
                                                          Model::CenterEnum)) &
                               Model::make,
                       "basis"_a, "center"_a);
        cls.def_static("makeGaussian", &Model::makeGaussian, "center"_a, "radius"_a = 1.0);
        cls.def("getNonlinearDim", &Model::getNonlinearDim);
        cls.def("getAmplitudeDim", &Model::getAmplitudeDim);
        cls.def("getFixedDim", &Model::getFixedDim);
        cls.def("getBasisCount", &Model::getBasisCount);
        cls.def("getNonlinearNames", &Model::getNonlinearNames, py::return_value_policy::copy);
        cls.def("getAmplitudeNames", &Model::getAmplitudeNames, py::return_value_policy::copy);
        cls.def("getFixedNames", &Model::getFixedNames, py::return_value_policy::copy);
        cls.def("getBasisVector", &Model::getBasisVector, py::return_value_policy::copy);
        cls.def("makeShapeletFunction", &Model::makeShapeletFunction);
        cls.def("adaptPrior", &Model::adaptPrior);
        cls.def("makeEllipseVector", &Model::makeEllipseVector);
        cls.def("writeEllipses",
                (Model::EllipseVector (Model::*)(ndarray::Array<Scalar const, 1, 1> const &,
                                                 ndarray::Array<Scalar const, 1, 1> const &) const) &
                        Model::writeEllipses,
                "nonlinear"_a, "fixed"_a);
        cls.def("readEllipses",
                (void (Model::*)(Model::EllipseVector const &, ndarray::Array<Scalar, 1, 1> const &,
                                 ndarray::Array<Scalar, 1, 1> const &) const) &
                        Model::readEllipses,
                "ellipses"_a, "nonlinear"_a, "fixed"_a);
        cls.def("transformParameters", &Model::transformParameters, "transform"_a, "nonlinear"_a, "amplitudes"_a,
                "fixed"_a);
    });
}

wrapMultiModel()

void lsst::meas::modelfit::wrapMultiModel

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file multiModel.cc.

                                                                   {
    // py::module::import("lsst.meas.modelfit.model");
    wrappers.wrapType(PyMultiModel(wrappers.module, "MultiModel"), [](auto &mod, auto &cls) {
        cls.def(py::init<ModelVector, MultiModel::NameVector const &>(), "components"_a, "prefixes"_a);
        cls.def("getComponents", &MultiModel::getComponents);
 
        // All other MultiModel methods are virtuals already inherited from
        // wrappers for Model.
    });
}

wrapOptimizer()

void lsst::meas::modelfit::wrapOptimizer

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 172 of file optimizer.cc.

                                                                  {
    auto clsObjective = declareOptimizerObjective(wrappers);
    auto clsControl = declareOptimizerControl(wrappers);
    auto clsHistoryRecorder = declareOptimizerHistoryRecorder(wrappers);
    auto cls = declareOptimizer(wrappers);
    cls.attr("Objective") = clsObjective;
    cls.attr("Control") = clsControl;
    cls.attr("HistoryRecorder") = clsHistoryRecorder;
 
    wrappers.module.def("solveTrustRegion", &solveTrustRegion, "x"_a, "F"_a, "g"_a, "r"_a, "tolerance"_a);
}

wrapPixelFitRegion()

void lsst::meas::modelfit::wrapPixelFitRegion

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 42 of file pixelFitRegion.cc.

                                                                       {
    using Control = PixelFitRegionControl;
 
    wrappers.wrapType(PyPixelFitRegionControl(wrappers.module, "PixelFitRegionControl"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        LSST_DECLARE_CONTROL_FIELD(cls, Control, nKronRadii);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, nPsfSigmaMin);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, nPsfSigmaGrow);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, nFitRadiiMin);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, nFitRadiiMax);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, maxArea);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, badMaskPlanes);
        LSST_DECLARE_CONTROL_FIELD(cls, Control, maxBadPixelFraction);
    });
 
    wrappers.wrapType(PyPixelFitRegion(wrappers.module, "PixelFitRegion"), [](auto &mod, auto &cls) {
        cls.def(py::init<Control const &, afw::geom::ellipses::Quadrupole const &,
                        afw::geom::ellipses::Quadrupole const &, Scalar, int>(),
                "ctrl"_a, "moments"_a, "psfMoments"_a, "kronRadius"_a, "footprintArea"_a);
        cls.def(py::init<Control const &, afw::geom::ellipses::Quadrupole const &>(), "ctrl"_a, "ellipse"_a);
        cls.def("applyEllipse", &PixelFitRegion::applyEllipse, "deconvolved"_a, "psfMoments"_a);
        cls.def("applyMask", &PixelFitRegion::applyMask, "mask"_a, "center"_a);
        // Data members are intentionally read-only from the Python side;
        // they should only be set by the constructor and apply methods.
        cls.def_readonly("ellipse", &PixelFitRegion::ellipse);
        cls.def_readonly("footprint", &PixelFitRegion::footprint);
        cls.def_readonly("usedFootprintArea", &PixelFitRegion::usedFootprintArea);
        cls.def_readonly("usedPsfArea", &PixelFitRegion::usedPsfArea);
        cls.def_readonly("maxArea", &PixelFitRegion::maxArea);
        cls.def_readonly("maxBadPixelFraction", &PixelFitRegion::maxBadPixelFraction);
        cls.def_readonly("usedMinEllipse", &PixelFitRegion::usedMinEllipse);
        cls.def_readonly("usedMaxEllipse", &PixelFitRegion::usedMaxEllipse);
    });
}

wrapPriors()

void lsst::meas::modelfit::wrapPriors

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 124 of file priors.cc.

                                                               {
    // py::module::import("lsst.meas.modelfit.mixture");
 
    declarePrior(wrappers);
    declareMixturePrior(wrappers);
    declareSemiEmpiricalPrior(wrappers);
    declareSoftenedLinearPrior(wrappers);
}

wrapPsf()

void lsst::meas::modelfit::wrapPsf

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 164 of file psf.cc.

                                                            {
    declareDoubleShapelet(wrappers);
    declareGeneral(wrappers);
}

wrapSampler()

void lsst::meas::modelfit::wrapSampler

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 44 of file sampler.cc.

                                                                {
    wrappers.wrapType(PySamplingObjective(wrappers.module, "SamplingObjective"), [](auto &mod, auto &cls) {
        cls.def("getParameterDim", &SamplingObjective::getParameterDim);
        cls.def("__call__", &SamplingObjective::operator(), "parameters"_a, "sample"_a);
    });
    wrappers.wrapType(PySampler(wrappers.module, "Sampler"), [](auto &mod, auto &cls) {
        cls.def("run", &Sampler::run, "objective"_a, "proposal"_a, "samples"_a);
    });
}

wrapTruncatedGaussian()

void lsst::meas::modelfit::wrapTruncatedGaussian

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 121 of file truncatedGaussian.cc.

                                                                          {
    declareSampleStrategy(wrappers);
    auto clsTruncatedGaussian = declareTruncatedGaussian(wrappers);
    clsTruncatedGaussian.attr("LogEvaluator") = declareEvaluator<LogEvaluator, PyLogEvaluator>(wrappers, "LogEvaluator");
    clsTruncatedGaussian.attr("Evaluator") = declareEvaluator<Evaluator, PyEvaluator>(wrappers, "Evaluator");
    clsTruncatedGaussian.attr("Sampler") = declareSampler(wrappers);
}

wrapUnitSystem()

void lsst::meas::modelfit::wrapUnitSystem

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file unitSystem.cc.

                                                                   {
    // Data member wrappers in this module are intentionally read-only;
    // setting them in Python should never be necessary and hence always
    // represents a mistake we want to fail on as early as possible.
    wrappers.wrapType(PyUnitSystem(wrappers.module, "UnitSystem"), [](auto &mod, auto &cls) {
        cls.def_readonly("wcs", &UnitSystem::wcs);
        cls.def_readonly("photoCalib", &UnitSystem::photoCalib);
        cls.def(
                py::init<geom::SpherePoint const &, std::shared_ptr<afw::image::PhotoCalib const>, double>(),
                "position"_a, "calibIn"_a, "flux"_a);
        cls.def(py::init<geom::SpherePoint const &, Scalar>(), "position"_a, "mag"_a);
        cls.def(
                py::init<std::shared_ptr<afw::geom::SkyWcs const>, std::shared_ptr<afw::image::PhotoCalib const>>(),
                "wcs"_a, "photoCalib"_a);
        cls.def(py::init<afw::image::Exposure<float> const &>(), "exposure"_a);
        cls.def(py::init<afw::image::Exposure<double> const &>(), "exposure"_a);
    });
 
    wrappers.wrapType(PyLocalUnitTransform(wrappers.module, "LocalUnitTransform"), [](auto &mod, auto &cls) {
        cls.def_readonly("geometric", &LocalUnitTransform::geometric);
        cls.def_readonly("flux", &LocalUnitTransform::flux);
        cls.def_readonly("sb", &LocalUnitTransform::sb);
        cls.def(py::init<geom::Point2D const &, UnitSystem const &, UnitSystem const &>(),
                                  "sourcePixel"_a, "source"_a, "destination"_a);
        cls.def(py::init<>());
    });
}

wrapUnitTransformedLikelihood()

void lsst::meas::modelfit::wrapUnitTransformedLikelihood

(

lsst::cpputils::python::WrapperCollection &

wrappers

)

Definition at line 48 of file unitTransformedLikelihood.cc.

                                                                                  {
    wrappers.wrapType(
            PyUnitTransformedLikelihoodControl(wrappers.module, "UnitTransformedLikelihoodControl"),
            [](auto &mod, auto &cls) {
                LSST_DECLARE_CONTROL_FIELD(cls, UnitTransformedLikelihoodControl, usePixelWeights);
                LSST_DECLARE_CONTROL_FIELD(cls, UnitTransformedLikelihoodControl, weightsMultiplier);
                cls.def(py::init<bool>(), "usePixelWeights"_a = false);
            });
    wrappers.wrapType(PyEpochFootprint(wrappers.module, "EpochFootprint"), [](auto &mod, auto &cls) {
        cls.def(py::init<afw::detection::Footprint const &, afw::image::Exposure<Pixel> const &,
                                      shapelet::MultiShapeletFunction const &>(),
                              "footprint"_a, "exposure"_a, "psf"_a);
        cls.def_readonly("footprint", &EpochFootprint::footprint);
        cls.def_readonly("exposure", &EpochFootprint::exposure);
        cls.def_readonly("psf", &EpochFootprint::psf);
    });
 
    wrappers.wrapType(PyUnitTransformedLikelihood(wrappers.module, "UnitTransformedLikelihood"),[](auto &mod, auto &cls) {
        cls.def(
                py::init<std::shared_ptr<Model>, ndarray::Array<Scalar const, 1, 1> const &, UnitSystem const &,
                        geom::SpherePoint const &, afw::image::Exposure<Pixel> const &,
                        afw::detection::Footprint const &, shapelet::MultiShapeletFunction const &,
                        UnitTransformedLikelihoodControl const &>(),
                "model"_a, "fixed"_a, "fitSys"_a, "position"_a, "exposure"_a, "footprint"_a, "psf"_a,
                "ctrl"_a);
        cls.def(
                py::init<std::shared_ptr<Model>, ndarray::Array<Scalar const, 1, 1> const &, UnitSystem const &,
                        geom::SpherePoint const &, std::vector<std::shared_ptr<EpochFootprint>> const &,
                        UnitTransformedLikelihoodControl const &>(),
                "model"_a, "fixed"_a, "fitSys"_a, "position"_a, "epochFootprintList"_a, "ctrl"_a);
    });
}