pybind11.h File Reference

#include <pybind11/pybind11.h>

Go to the source code of this file.

Functions
void	bind_centroidparameters (py::module &m)
void	bind_channel (py::module &m)
void	bind_chromatic (const py::module &m)
void	bind_component (py::module &m)
void	bind_componentmixture (py::module &m)
void	bind_data (py::module &m)
void	bind_ellipticalcomponent (py::module &m)
void	bind_fractionalintegralmodel (py::module &m)
void	bind_gaussiancomponent (py::module &m)
void	bind_gaussianmodelintegral (py::module &m)
void	bind_gaussianparametricellipse (py::module &m)
void	bind_gaussianprior (py::module &m)
void	bind_integralmodel (py::module &m)
void	bind_interpolation (py::module &m)
void	bind_linearintegralmodel (py::module &m)
void	bind_linearsersicmixinterpolator (py::module &m)
void	bind_model (py::module &m)
void	bind_observation (py::module &m)
void	bind_param_filter (py::module &m)
void	bind_parameters (py::module &m)
void	bind_parametric (py::module &m)
void	bind_parametricgaussian1d (py::module &m)
void	bind_parametricellipse (py::module &m)
void	bind_parametricmodel (py::module &m)
void	bind_prior (py::module &m)
void	bind_psfmodel (py::module &m)
void	bind_sersicmix (py::module &m)
void	bind_sersicmixcomponent (py::module &m)
void	bind_sersicparametricellipse (py::module &m)
void	bind_shapeprior (py::module &m)
void	bind_source (py::module &m)

Function Documentation

bind_centroidparameters()

void bind_centroidparameters

(

py::module &

m

)

Definition at line 39 of file centroidparameters.cc.

                                          {
    auto _c = py::classh<g2f::CentroidParameters, lsst::gauss2d::CentroidData>(m, "CentroidParameters")
                      .def(py::init<double, double>(), "x"_a = 0, "y"_a = 0)
                      .def(py::init<std::shared_ptr<g2f::CentroidXParameterD>,
                                    std::shared_ptr<g2f::CentroidYParameterD>>(),
                           "x"_a = nullptr, "y"_a = nullptr)
                      .def_property("x", &g2f::CentroidParameters::get_x, &g2f::CentroidParameters::set_x)
                      .def_property("y", &g2f::CentroidParameters::get_y, &g2f::CentroidParameters::set_y)
                      .def_property("xy", &g2f::CentroidParameters::get_xy, &g2f::CentroidParameters::set_xy)
                      .def_property_readonly("x_param", &g2f::CentroidParameters::get_x_param)
                      .def_property_readonly("y_param", &g2f::CentroidParameters::get_y_param)
                      .def_property_readonly("x_param_ptr", &g2f::CentroidParameters::get_x_param_ptr)
                      .def_property_readonly("y_param_ptr", &g2f::CentroidParameters::get_y_param_ptr)
                      .def("__repr__", [](const g2f::CentroidParameters &self) { return self.repr(true); })
                      .def("__str__", &g2f::CentroidParameters::str);
}

bind_channel()

void bind_channel

(

py::module &

m

)

Definition at line 37 of file channel.cc.

                               {
    auto _c = py::classh<g2f::Channel, lsst::gauss2d::Object>(m, "Channel")
                      .def(py::init(&g2f::Channel::make))
                      .def_static("erase", &g2f::Channel::erase)
                      .def_property_readonly_static("all",
                                                    [](py::object) { return g2f::Channel::get_channels(); })
                      .def_static("find", &g2f::Channel::find_channel)
                      .def_static("get", &g2f::Channel::get_channel)
                      .def_readonly("name", &g2f::Channel::name)
                      .def_property_readonly_static("NONE",
                                                    [](py::object) { return g2f::Channel::NONE_PTR(); })
                      .def("__repr__", [](const g2f::Channel &self) { return self.repr(true); })
                      .def("__str__", &g2f::Channel::str);
    /*
        const bool operator < ( const Channel &c ) const;
        const bool operator == ( const Channel &c ) const;
        const bool operator != ( const Channel &c ) const;
    */
}

bind_chromatic()

void bind_chromatic

(

const py::module &

m

)

Definition at line 36 of file chromatic.cc.

{ auto _p = py::classh<g2f::Chromatic>(m, "Chromatic"); }

bind_component()

void bind_component

(

py::module &

m

)

Definition at line 37 of file component.cc.

                                 {
    auto _c = py::classh<g2f::Component, g2f::ParametricModel>(m, "Component");
}

bind_componentmixture()

void bind_componentmixture

(

py::module &

m

)

Definition at line 37 of file componentmixture.cc.

                                        {
    auto _c = py::classh<g2f::ComponentMixture, g2f::ParametricModel>(m, "ComponentMixture");
}

bind_data()

void bind_data

(

py::module &

m

)

Definition at line 66 of file data.cc.

                            {
    declare_data<double>(m, "D");
    declare_data<float>(m, "F");
}

bind_ellipticalcomponent()

void bind_ellipticalcomponent

(

py::module &

m

)

Definition at line 36 of file ellipticalcomponent.cc.

                                           {
    auto _e = py::classh<g2f::EllipticalComponent, g2f::Component>(m, "EllipticalComponent")
                      .def_property_readonly("centroid", &g2f::EllipticalComponent::get_centroid)
                      .def_property_readonly("ellipse", &g2f::EllipticalComponent::get_ellipse)
                      .def_property_readonly("integralmodel", &g2f::EllipticalComponent::get_integralmodel);
}

bind_fractionalintegralmodel()

void bind_fractionalintegralmodel

(

py::module &

m

)

Definition at line 39 of file fractionalintegralmodel.cc.

                                               {
    auto _p = py::classh<g2f::FractionalIntegralModel, g2f::IntegralModel>(m, "FractionalIntegralModel")
                      .def(py::init(&g2f::FractionalIntegralModel::make), "data"_a, "model"_a,
                           "is_final"_a = false)
                      .def_property_readonly("channels", &g2f::FractionalIntegralModel::get_channels)
                      .def("integral", &g2f::FractionalIntegralModel::get_integral, "channel"_a)
                      .def("integral_remainder", &g2f::FractionalIntegralModel::get_integral_remainder,
                           "channel"_a)
                      .def("parameters", &g2f::FractionalIntegralModel::get_parameters,
                           "parameters"_a = g2f::ParamRefs(), "paramfilter"_a = nullptr)
                      .def_property_readonly("parent_model", &g2f::FractionalIntegralModel::get_parent_model)
                      .def_static("model", &g2f::FractionalIntegralModel::find_model)
                      .def("__getitem__", [](const g2f::FractionalIntegralModel &self,
                                             const g2f::Channel &c) { return self.at(c); })
                      .def("__len__", &g2f::FractionalIntegralModel::size)
                      .def("__repr__",
                           [](const g2f::FractionalIntegralModel &self) { return self.repr(true); })
                      .def("__str__", &g2f::FractionalIntegralModel::str);
}

bind_gaussiancomponent()

void bind_gaussiancomponent

(

py::module &

m

)

Definition at line 40 of file gaussiancomponent.cc.

                                         {
    auto _e = py::classh<g2f::GaussianComponent, g2f::EllipticalComponent>(m, "GaussianComponent")
                      .def(py::init<std::shared_ptr<g2f::GaussianParametricEllipse>,
                                    std::shared_ptr<g2f::CentroidParameters>,
                                    std::shared_ptr<g2f::IntegralModel>>(),
                           "ellipse"_a = nullptr, "centroid"_a = nullptr, "integral"_a = nullptr)
                      .def("parameters", &g2f::GaussianComponent::get_parameters,
                           "parameters"_a = g2f::ParamRefs(), "paramfilter"_a = nullptr)
                      .def("gaussians",
                           [](const g2f::GaussianComponent &g, const g2f::Channel &c) {
                               return std::shared_ptr<const lsst::gauss2d::Gaussians>(g.get_gaussians(c));
                           })
                      .def_static("make_uniq_default_gaussians",
                                  &g2f::GaussianComponent::make_uniq_default_gaussians, "sizes"_a, "fixed"_a)
                      .def("__repr__", [](const g2f::GaussianComponent &self) { return self.repr(true); })
                      .def("__str__", &g2f::GaussianComponent::str);
}

bind_gaussianmodelintegral()

void bind_gaussianmodelintegral

(

py::module &

m

)

Definition at line 42 of file gaussianmodelintegral.cc.

                                             {
    auto _p = py::classh<g2f::GaussianModelIntegral, lsst::gauss2d::GaussianIntegral>(m,
                                                                                      "GaussianModelIntegral")
                      .def(py::init<const g2f::Channel &, const std::shared_ptr<const g2f::IntegralModel>>(),
                           "channel"_a, "integralmodel"_a)
                      .def_property("value", &g2f::GaussianModelIntegral::get_value,
                                    &g2f::GaussianModelIntegral::set_value)
                      .def("__repr__", [](const g2f::GaussianModelIntegral &self) { return self.repr(true); })
                      .def("__str__", &g2f::GaussianModelIntegral::str);
    /*
        typename Data::iterator begin() noexcept;
        typename Data::const_iterator cbegin() const noexcept;
 
        typename Data::iterator end() noexcept;
        typename Data::const_iterator cend() const noexcept;
    */
}

bind_gaussianparametricellipse()

void bind_gaussianparametricellipse

(

py::module &

m

)

Definition at line 39 of file gaussianparametricellipse.cc.

                                                 {
    auto _e = py::classh<g2f::GaussianParametricEllipse, lsst::gauss2d::EllipseData, g2f::ParametricEllipse>(
                      m, "GaussianParametricEllipse")
                      .def(py::init<double, double, double>(), "sigma_x"_a = 0, "sigma_y"_a = 0, "rho"_a = 0)
                      .def(py::init<std::shared_ptr<g2f::SigmaXParameterD>,
                                    std::shared_ptr<g2f::SigmaYParameterD>,
                                    std::shared_ptr<g2f::RhoParameterD> >(),
                           "sigma_x"_a = nullptr, "sigma_y"_a = nullptr, "rho"_a = nullptr)
                      .def_property("rho", &g2f::GaussianParametricEllipse::get_rho,
                                    &g2f::GaussianParametricEllipse::set_rho)
                      .def_property("sigma_x", &g2f::GaussianParametricEllipse::get_sigma_x,
                                    &g2f::GaussianParametricEllipse::set_sigma_x)
                      .def_property("sigma_y", &g2f::GaussianParametricEllipse::get_sigma_y,
                                    &g2f::GaussianParametricEllipse::set_sigma_y)
                      .def_property("size_x", &g2f::GaussianParametricEllipse::get_size_x,
                                    &g2f::GaussianParametricEllipse::set_size_x)
                      .def_property("size_y", &g2f::GaussianParametricEllipse::get_size_y,
                                    &g2f::GaussianParametricEllipse::set_size_y)
                      .def_property("xyr", &g2f::GaussianParametricEllipse::get_xyr,
                                    &g2f::GaussianParametricEllipse::set_xyr)
                      .def_property_readonly("rho_param", &g2f::GaussianParametricEllipse::get_rho_param)
                      .def_property_readonly("sigma_x_param",
                                             &g2f::GaussianParametricEllipse::get_sigma_x_param)
                      .def_property_readonly("sigma_y_param",
                                             &g2f::GaussianParametricEllipse::get_sigma_y_param)
                      .def_property_readonly("size_x_param",
                                             &g2f::GaussianParametricEllipse::get_size_x_param)
                      .def_property_readonly("size_y_param",
                                             &g2f::GaussianParametricEllipse::get_size_y_param)
                      .def_property_readonly("rho_param_ptr",
                                             &g2f::GaussianParametricEllipse::get_rho_param_ptr)
                      .def_property_readonly("sigma_x_param_ptr",
                                             &g2f::GaussianParametricEllipse::get_sigma_x_param_ptr)
                      .def_property_readonly("sigma_y_param_ptr",
                                             &g2f::GaussianParametricEllipse::get_sigma_y_param_ptr)
                      .def_property_readonly("size_x_param_ptr",
                                             &g2f::GaussianParametricEllipse::get_size_x_param_ptr)
                      .def_property_readonly("size_y_param_ptr",
                                             &g2f::GaussianParametricEllipse::get_size_y_param_ptr)
                      .def("set", &g2f::GaussianParametricEllipse::set)
                      .def("__repr__",
                           [](const g2f::GaussianParametricEllipse &self) { return self.repr(true); })
                      .def("__str__", &g2f::GaussianParametricEllipse::str);
}

bind_gaussianprior()

void bind_gaussianprior

(

py::module &

m

)

Definition at line 40 of file gaussianprior.cc.

                                     {
    auto _e = py::classh<g2f::GaussianPrior, g2f::Prior>(m, "GaussianPrior")
                      .def(py::init<std::shared_ptr<const g2f::ParamBase>, double, double, bool>(),
                           "param"_a = nullptr, "mean"_a = 0, "stddev"_a = 1., "transformed"_a = false)
                      .def("evaluate", &g2f::GaussianPrior::evaluate, "calc_jacobians"_a = false,
                           "normalize_loglike"_a = false)
                      .def_property_readonly("loglike_const_terms",
                                             &g2f::GaussianPrior::get_loglike_const_terms)
                      .def_property("mean", &g2f::GaussianPrior::get_mean, &g2f::GaussianPrior::set_mean)
                      .def_property_readonly("param", &g2f::GaussianPrior::get_param)
                      .def_property("stddev", &g2f::GaussianPrior::get_stddev,
                                    &g2f::GaussianPrior::set_stddev)
                      .def_property("transformed", &g2f::GaussianPrior::get_transformed,
                                    &g2f::GaussianPrior::set_transformed)
                      .def("__len__", &g2f::GaussianPrior::size)
                      .def("__repr__", [](const g2f::GaussianPrior &self) { return self.repr(true); })
                      .def("__str__", &g2f::GaussianPrior::str);
}

bind_integralmodel()

void bind_integralmodel

(

py::module &

m

)

Definition at line 36 of file integralmodel.cc.

                                     {
    auto _p = py::classh<g2f::IntegralModel, g2f::Chromatic>(m, "IntegralModel");
}

bind_interpolation()

void bind_interpolation

(

py::module &

m

)

Definition at line 36 of file interpolation.cc.

                                     {
    auto _e = py::enum_<g2f::InterpType>(m, "InterpType")
                      .value("linear", g2f::InterpType::linear)
                      .value("polynomial", g2f::InterpType::polynomial)
                      .value("cspline", g2f::InterpType::cspline)
                      .value("akima", g2f::InterpType::akima);
}

bind_linearintegralmodel()

void bind_linearintegralmodel

(

py::module &

m

)

Definition at line 38 of file linearintegralmodel.cc.

                                           {
    auto _p = py::classh<g2f::LinearIntegralModel, g2f::IntegralModel>(m, "LinearIntegralModel")
                      .def(py::init<const g2f::LinearIntegralModel::Data *>(), "data"_a)
                      .def_property_readonly("channels", &g2f::LinearIntegralModel::get_channels)
                      .def("integral", &g2f::LinearIntegralModel::get_integral, "channel"_a)
                      .def("parameters", &g2f::LinearIntegralModel::get_parameters,
                           "parameters"_a = g2f::ParamRefs(), "paramfilter"_a = nullptr)
                      .def("__getitem__", [](const g2f::LinearIntegralModel &self,
                                             const g2f::Channel &c) { return self.at(c); })
                      .def("__len__", &g2f::LinearIntegralModel::size)
                      .def("__repr__", [](const g2f::LinearIntegralModel &self) { return self.repr(true); })
                      .def("__str__", &g2f::LinearIntegralModel::str);
    /*
        typename Data::iterator begin() noexcept;
        typename Data::const_iterator cbegin() const noexcept;
 
        typename Data::iterator end() noexcept;
        typename Data::const_iterator cend() const noexcept;
    */
}

bind_linearsersicmixinterpolator()

void bind_linearsersicmixinterpolator

(

py::module &

m

)

Definition at line 37 of file linearsersicmixinterpolator.cc.

                                                   {
    auto _e = py::classh<g2f::LinearSersicMixInterpolator, g2f::SersicMixInterpolator>(
                      m, "LinearSersicMixInterpolator")
                      .def(py::init<short>(), "order"_a = g2f::SERSICMIX_ORDER_DEFAULT)
                      .def("integralsizes", &g2f::LinearSersicMixInterpolator::get_integralsizes)
                      .def("integralsizes_derivs",
                           &g2f::LinearSersicMixInterpolator::get_integralsizes_derivs)
                      .def_property_readonly("order", &g2f::LinearSersicMixInterpolator::get_order)
                      .def("__repr__",
                           [](const g2f::LinearSersicMixInterpolator &self) { return self.repr(true); })
                      .def("__str__", &g2f::LinearSersicMixInterpolator::str);
}

bind_model()

void bind_model

(

py::module &

m

)

Definition at line 89 of file model.cc.

                             {
    auto _e = py::enum_<g2f::EvaluatorMode>(m, "EvaluatorMode")
                      .value("image", g2f::EvaluatorMode::image)
                      .value("loglike", g2f::EvaluatorMode::loglike)
                      .value("loglike_image", g2f::EvaluatorMode::loglike_image)
                      .value("loglike_grad", g2f::EvaluatorMode::loglike_grad)
                      .value("jacobian", g2f::EvaluatorMode::jacobian)
                      .export_values();
    auto _h = py::classh<g2f::HessianOptions>(m, "HessianOptions")
                      .def(py::init<bool, double, double>(), "return_negative"_a = true,
                           "findiff_frac"_a = 1e-4, "findiff_add"_a = 1e-4)
                      .def_readwrite("return_negative", &g2f::HessianOptions::return_negative)
                      .def_readwrite("findiff_frac", &g2f::HessianOptions::return_negative)
                      .def_readwrite("findiff_add", &g2f::HessianOptions::return_negative);
    declare_model<double>(m, "D");
    declare_model<float>(m, "F");
}

bind_observation()

void bind_observation

(

py::module &

m

)

Definition at line 64 of file observation.cc.

                                   {
    declare_observation<double>(m, "D");
    declare_observation<float>(m, "F");
}

bind_param_filter()

void bind_param_filter

(

py::module &

m

)

Definition at line 38 of file param_filter.cc.

                                    {
    auto _p = py::classh<g2f::ParamFilter>(m, "ParamFilter")
                      .def(py::init<bool, bool, bool, bool,
                                    std::optional<std::reference_wrapper<const g2f::Channel>>>(),
                           "fixed"_a = true, "free"_a = true, "linear"_a = true, "nonlinear"_a = true,
                           "channel"_a = std::nullopt)
                      .def_readwrite("channel", &g2f::ParamFilter::channel)
                      .def_readwrite("fixed", &g2f::ParamFilter::fixed)
                      .def_readwrite("free", &g2f::ParamFilter::free)
                      .def_readwrite("linear", &g2f::ParamFilter::linear)
                      .def_readwrite("nonlinear", &g2f::ParamFilter::nonlinear);
}

bind_parameters()

void bind_parameters

(

py::module &

m

)

Definition at line 44 of file parameters.cc.

                                  {
    auto _u = py::classh<parameters::Unit>(m, "Unit");
    py::classh<g2f::UnitNone, parameters::Unit>(m, "UnitNone")
            .def(py::init<>())
            .def_property_readonly("name", &g2f::UnitNone::get_name);
    declare_limits<double>(m);
    using Parameter = parameters::ParameterBase<double>;
    auto _p = py::classh<Parameter>(m, "ParameterD");
    auto integral = declare_parameter<double, g2f::IntegralParameterD>(m, "Integral");
    integral.def_property("label", &g2f::IntegralParameterD::get_label, &g2f::IntegralParameterD::set_label);
    declare_parameter<double, g2f::CentroidXParameterD>(m, "CentroidX");
    declare_parameter<double, g2f::CentroidYParameterD>(m, "CentroidY");
    declare_parameter<double, g2f::MeanParameterD>(m, "Mean");
    declare_parameter<double, g2f::MoffatConcentrationParameterD>(m, "MoffatConcentration");
    auto propfrac = declare_parameter<double, g2f::ProperFractionParameterD>(m, "ProperFraction");
    propfrac.def_property("label", &g2f::ProperFractionParameterD::get_label,
                          &g2f::ProperFractionParameterD::set_label);
    declare_sizeparameter_base<double, g2f::SizeXParameterD, g2f::SizeYParameterD>(m);
    declare_parameter<double, g2f::RadiusScaleParameterD>(m, "RadiusScale");
    declare_sizeparameter<double, g2f::ReffXParameterD, g2f::SizeXParameterD>(m, "ReffX");
    declare_sizeparameter<double, g2f::ReffYParameterD, g2f::SizeYParameterD>(m, "ReffY");
    declare_parameter<double, g2f::RhoParameterD>(m, "Rho");
    declare_parameter<double, g2f::SersicIndexParameterD>(m, "SersicIndex");
    declare_sizeparameter<double, g2f::SigmaXParameterD, g2f::SizeXParameterD>(m, "SigmaX");
    declare_sizeparameter<double, g2f::SigmaYParameterD, g2f::SizeYParameterD>(m, "SigmaY");
    declare_parameter<double, g2f::StdDevParameterD>(m, "StdDev");
    declare_transform_base<double>(m);
    declare_transform<double, lsst::modelfit::parameters::UnitTransform<double>>(m, "Unit");
    declare_transform<double, g2f::InverseTransform>(m, "Inverse");
    declare_transform<double, g2f::JanskyToABMagTransform>(m, "JanskyToABMag");
    declare_transform<double, g2f::NanojanskyToABMagTransform>(m, "NanojanskyToABMag");
    declare_transform<double, g2f::LogTransform>(m, "Log");
    declare_transform<double, g2f::Log10Transform>(m, "Log10");
    declare_transform<double, g2f::LogitTransform>(m, "Logit");
    // TODO: Determine why this won't work with std::shared_ptr<parameters::Limits<double>>
    declare_transform_full<double, g2f::LogitLimitedTransform, true, true,
                           std::shared_ptr<parameters::Limits<double>>, double>(m, "LogitLimited");
    const std::vector<std::reference_wrapper<Parameter>> _default = {};
    m.def("params_unique", &g2f::nonconsecutive_unique<std::reference_wrapper<Parameter>>,
          "params"_a = _default);
}

bind_parametric()

void bind_parametric

(

py::module &

m

)

Definition at line 37 of file parametric.cc.

                                  {
    auto _p = py::classh<g2f::Parametric, lsst::gauss2d::Object>(m, "Parametric");
}

bind_parametricellipse()

void bind_parametricellipse

(

py::module &

m

)

Definition at line 36 of file parametricellipse.cc.

                                         {
    auto _p = py::classh<g2f::ParametricEllipse, g2f::Parametric>(m, "ParametricEllipse");
}

bind_parametricgaussian1d()

void bind_parametricgaussian1d

(

py::module &

m

)

Definition at line 38 of file parametricgaussian1d.cc.

                                            {
    auto _e = py::classh<g2f::ParametricGaussian1D, lsst::gauss2d::Object>(m, "ParametricGaussian1D")
                      .def(py::init<std::shared_ptr<g2f::MeanParameterD>,
                                    std::shared_ptr<g2f::StdDevParameterD>>(),
                           "mean"_a = nullptr, "stddev"_a = nullptr)
                      .def_property("mean", &g2f::ParametricGaussian1D::get_mean,
                                    &g2f::ParametricGaussian1D::set_mean)
                      .def_property_readonly("mean_parameter", &g2f::ParametricGaussian1D::get_mean_parameter)
                      .def_property("stddev", &g2f::ParametricGaussian1D::get_stddev,
                                    &g2f::ParametricGaussian1D::set_stddev)
                      .def_property_readonly("stddev_parameter",
                                             &g2f::ParametricGaussian1D::get_stddev_parameter)
                      .def("__repr__", [](const g2f::ParametricGaussian1D &self) { return self.repr(true); })
                      .def("__str__", &g2f::ParametricGaussian1D::str);
}

bind_parametricmodel()

void bind_parametricmodel

(

py::module &

m

)

Definition at line 37 of file parametricmodel.cc.

                                       {
    auto _p = py::classh<g2f::ParametricModel, g2f::Parametric>(m, "ParametricModel");
}

bind_prior()

void bind_prior

(

py::module &

m

)

Definition at line 38 of file prior.cc.

                             {
    auto _e = py::classh<g2f::PriorEvaluation, lsst::gauss2d::Object>(m, "PriorEvaluation")
                      .def(py::init<double, std::vector<double>,
                                    std::map<g2f::ParamBaseCRef, std::vector<double>>>(),
                           "loglike"_a, "residuals"_a = std::vector<double>{},
                           "jacobians"_a = std::map<g2f::ParamBaseCRef, std::vector<double>>{})
                      .def_readonly("loglike", &g2f::PriorEvaluation::loglike)
                      .def_readonly("jacobians", &g2f::PriorEvaluation::jacobians)
                      .def_readonly("residuals", &g2f::PriorEvaluation::residuals)
                      .def("__repr__", [](const g2f::PriorEvaluation &self) { return self.repr(true); })
                      .def("__str__", &g2f::PriorEvaluation::str);
    auto _p = py::classh<g2f::Prior, lsst::gauss2d::Object>(m, "Prior");
}

bind_psfmodel()

void bind_psfmodel

(

py::module &

m

)

Definition at line 39 of file psfmodel.cc.

                                {
    auto _o = py::classh<g2f::PsfModel, g2f::ComponentMixture>(m, "PsfModel")
                      .def(py::init<g2f::Components &>(), "components"_a = nullptr)
                      .def_property_readonly("components", &g2f::PsfModel::get_components)
                      .def("gaussians",
                           [](const g2f::PsfModel &p, const g2f::Channel &c) {
                               return std::shared_ptr<const lsst::gauss2d::Gaussians>(p.get_gaussians(c));
                           })
                      .def("parameters", &g2f::PsfModel::get_parameters, "parameters"_a = g2f::ParamRefs(),
                           "paramfilter"_a = nullptr)
                      .def("__repr__", [](const g2f::PsfModel &self) { return self.repr(true); })
                      .def("__str__", &g2f::PsfModel::str);
}

bind_sersicmix()

void bind_sersicmix

(

py::module &

m

)

Definition at line 36 of file sersicmix.cc.

                                 {
    auto _is = py::classh<g2f::IntegralSize, lsst::gauss2d::Object>(m, "IntegralSize")
                       .def(py::init<const double, const double>(), "integral"_a = 0, "sigma"_a = 0)
                       .def_readonly("integral", &g2f::IntegralSize::integral)
                       .def_readonly("sigma", &g2f::IntegralSize::sigma)
                       .def("__repr__", [](const g2f::IntegralSize &self) { return self.repr(true); })
                       .def("__str__", &g2f::IntegralSize::str);
 
    auto _smi = py::classh<g2f::SersicMixInterpolator, lsst::gauss2d::Object>(m, "SersicMixInterpolator");
 
    auto _smv = py::classh<g2f::SersicMixValues, lsst::gauss2d::Object>(m, "SersicMixValues")
                        .def(py::init<double, std::vector<g2f::IntegralSize>>(), "sersicindex"_a, "values"_a)
                        .def_readonly("sersicindex", &g2f::SersicMixValues::sersicindex)
                        .def_readonly("values", &g2f::SersicMixValues::values)
                        .def("__repr__", [](const g2f::SersicMixValues &self) { return self.repr(true); })
                        .def("__str__", &g2f::SersicMixValues::str);
 
    m.def("sersic_mix_knots", &g2f::get_sersic_mix_knots_copy, "order"_a = g2f::SERSICMIX_ORDER_DEFAULT,
          py::return_value_policy::copy);
}

bind_sersicmixcomponent()

void bind_sersicmixcomponent

(

py::module &

m

)

Definition at line 43 of file sersicmixcomponent.cc.

                                          {
    using T = double;
    using C = g2f::SersicMixComponentIndexParameterD;
    using Base = g2f::SersicIndexParameterD;
 
    std::string pyclass_name = "SersicMixComponentIndexParameter" + g2f::suffix_type_str<T>();
    declare_parameter_methods<C, C, Base>(
            // note that Base is the actual name of the base Parameter class, not the CRTP class
            // that it is "derived" from
            py::classh<C, Base>(m, pyclass_name.c_str()))
            // new properties
            .def_property_readonly("integralratio",
                                   &g2f::SersicMixComponentIndexParameterD::get_integralratio)
            .def_property_readonly("interptype", &g2f::SersicMixComponentIndexParameterD::get_interptype)
            .def_property_readonly("order", &g2f::SersicMixComponentIndexParameterD::get_order)
            .def_property_readonly("sizeratio", &g2f::SersicMixComponentIndexParameterD::get_sizeratio)
            // constructor with added arg
            .def(py::init<T, std::shared_ptr<const parameters::Limits<T>>,
                          std::shared_ptr<const parameters::Transform<T>>,
                          std::shared_ptr<const parameters::Unit>, bool, std::string,
                          const std::shared_ptr<const g2f::SersicMixInterpolator>>(),
                 "value"_a = g2f::SersicMixComponentIndexParameterD::_get_default(), "limits"_a = nullptr,
                 "transform"_a = nullptr, "unit"_a = lsst::gauss2d::fit::unit_none, "fixed"_a = false,
                 "label"_a = "", "interpolator"_a = nullptr);
 
    auto _e = py::classh<g2f::SersicMixComponent, g2f::EllipticalComponent>(m, "SersicMixComponent")
                      .def(py::init<std::shared_ptr<g2f::SersicParametricEllipse>,
                                    std::shared_ptr<g2f::CentroidParameters>,
                                    std::shared_ptr<g2f::IntegralModel>,
                                    std::shared_ptr<g2f::SersicMixComponentIndexParameterD>>(),
                           "ellipse"_a = nullptr, "centroid"_a = nullptr, "integral"_a = nullptr,
                           "sersicindex"_a = nullptr)
                      .def_property("sersicindex", &g2f::SersicMixComponent::get_sersicindex,
                                    &g2f::SersicMixComponent::set_sersicindex)
                      .def_property_readonly("sersicindex_param",
                                             &g2f::SersicMixComponent::get_sersicindex_param)
                      .def_property_readonly("sersicindex_param_ptr",
                                             &g2f::SersicMixComponent::get_sersicindex_param_ptr)
                      .def("parameters", &g2f::SersicMixComponent::get_parameters,
                           "parameters"_a = g2f::ParamRefs(), "paramfilter"_a = nullptr)
                      .def("gaussians",
                           [](const g2f::SersicMixComponent &g, const g2f::Channel &c) {
                               return std::shared_ptr<const lsst::gauss2d::Gaussians>(g.get_gaussians(c));
                           })
                      .def("__repr__", [](const g2f::SersicMixComponent &self) { return self.repr(true); })
                      .def("__str__", &g2f::SersicMixComponent::str);
}

bind_sersicparametricellipse()

void bind_sersicparametricellipse

(

py::module &

m

)

Definition at line 39 of file sersicparametricellipse.cc.

                                               {
    auto _e = py::classh<g2f::SersicParametricEllipse, g2f::ParametricEllipse>(m, "SersicParametricEllipse")
                      .def(py::init<double, double, double>(), "size_x"_a = 0, "size_y"_a = 0, "rho"_a = 0)
                      .def(py::init<std::shared_ptr<g2f::ReffXParameterD>,
                                    std::shared_ptr<g2f::ReffYParameterD>,
                                    std::shared_ptr<g2f::RhoParameterD> >(),
                           "size_x"_a = nullptr, "size_y"_a = nullptr, "rho"_a = nullptr)
                      .def_property("rho", &g2f::SersicParametricEllipse::get_rho,
                                    &g2f::SersicParametricEllipse::set_rho)
                      .def_property("size_x", &g2f::SersicParametricEllipse::get_size_x,
                                    &g2f::SersicParametricEllipse::set_size_x)
                      .def_property("size_y", &g2f::SersicParametricEllipse::get_size_y,
                                    &g2f::SersicParametricEllipse::set_size_y)
                      .def_property("xyr", &g2f::SersicParametricEllipse::get_xyr,
                                    &g2f::SersicParametricEllipse::set_xyr)
                      .def_property_readonly("rho_param", &g2f::SersicParametricEllipse::get_rho_param)
                      .def_property_readonly("size_x_param", &g2f::SersicParametricEllipse::get_size_x_param)
                      .def_property_readonly("size_y_param", &g2f::SersicParametricEllipse::get_size_y_param)
                      .def_property_readonly("rho_param_ptr",
                                             &g2f::SersicParametricEllipse::get_rho_param_ptr)
                      .def_property_readonly("size_x_param_ptr",
                                             &g2f::SersicParametricEllipse::get_size_x_param_ptr)
                      .def_property_readonly("size_y_param_ptr",
                                             &g2f::SersicParametricEllipse::get_size_y_param_ptr)
                      .def("__repr__",
                           [](const g2f::SersicParametricEllipse &self) { return self.repr(true); })
                      .def("__str__", &g2f::SersicParametricEllipse::str);
}

bind_shapeprior()

void bind_shapeprior

(

py::module &

m

)

Definition at line 41 of file shapeprior.cc.

                                  {
    auto _o = py::classh<g2f::ShapePriorOptions, lsst::gauss2d::Object>(m, "ShapePriorOptions")
                      .def(py::init<double, double, double>(),
                           "delta_jacobian"_a = g2f::ShapePriorOptions::delta_jacobian_default,
                           "size_maj_floor"_a = g2f::ShapePriorOptions::size_maj_floor_default,
                           "axrat_floor"_a = g2f::ShapePriorOptions::axrat_floor_default)
                      .def("check_delta_jacobian", &g2f::ShapePriorOptions::check_delta_jacobian)
                      .def("check_size_maj_floor", &g2f::ShapePriorOptions::check_size_maj_floor)
                      .def("check_axrat_floor", &g2f::ShapePriorOptions::check_axrat_floor)
                      .def_property("delta_jacobian", &g2f::ShapePriorOptions::get_delta_jacobian,
                                    &g2f::ShapePriorOptions::set_delta_jacobian)
                      .def_property("size_maj_floor", &g2f::ShapePriorOptions::get_size_maj_floor,
                                    &g2f::ShapePriorOptions::set_size_maj_floor)
                      .def_property("size_maj_floor", &g2f::ShapePriorOptions::get_size_maj_floor,
                                    &g2f::ShapePriorOptions::set_size_maj_floor)
                      .def("__repr__", [](const g2f::ShapePriorOptions &self) { return self.repr(true); })
                      .def("__str__", &g2f::ShapePriorOptions::str);
 
    auto _s = py::classh<g2f::ShapePrior, g2f::Prior>(m, "ShapePrior")
                      .def(py::init<std::shared_ptr<const g2f::ParametricEllipse>,
                                    std::shared_ptr<g2f::ParametricGaussian1D>,
                                    std::shared_ptr<g2f::ParametricGaussian1D>,
                                    std::shared_ptr<g2f::ShapePriorOptions> >(),
                           "ellipse"_a, "prior_size"_a = nullptr, "prior_axrat"_a = nullptr,
                           "options"_a = nullptr)
                      .def("evaluate", &g2f::ShapePrior::evaluate, "calc_jacobians"_a = false,
                           "normalize_loglike"_a = false)
                      .def_property_readonly("loglike_const_terms", &g2f::ShapePrior::get_loglike_const_terms)
                      .def_property("prior_size", &g2f::ShapePrior::get_prior_size,
                                    &g2f::ShapePrior::set_prior_size)
                      .def_property("prior_axrat", &g2f::ShapePrior::get_prior_axrat,
                                    &g2f::ShapePrior::set_prior_axrat)
                      .def("__len__", &g2f::ShapePrior::size)
                      .def("__repr__", [](const g2f::ShapePrior &self) { return self.repr(true); })
                      .def("__str__", &g2f::ShapePrior::str);
}

bind_source()

void bind_source

(

py::module &

m

)

Definition at line 38 of file source.cc.

                              {
    auto _s = py::classh<g2f::Source, g2f::ComponentMixture>(m, "Source")
                      .def(py::init<g2f::Components &>(), "components"_a = nullptr)
                      .def_property_readonly("components", &g2f::Source::get_components)
                      .def("gaussians",
                           [](const g2f::Source &g, const g2f::Channel &c) {
                               return std::shared_ptr<const lsst::gauss2d::Gaussians>(g.get_gaussians(c));
                           })
                      .def("parameters", &g2f::Source::get_parameters, "parameters"_a = g2f::ParamRefs(),
                           "paramfilter"_a = nullptr)
                      .def("__repr__", [](const g2f::Source &self) { return self.repr(true); })
                      .def("__str__", &g2f::Source::str);
}