lsst::gauss2d::fit::ShapePrior Class Reference

A two-part prior on the shape of a parametric ellipse. More...

#include <shapeprior.h>

Inheritance diagram for lsst::gauss2d::fit::ShapePrior:

Public Member Functions
	ShapePrior (std::shared_ptr< const ParametricEllipse > ellipse, std::shared_ptr< ParametricGaussian1D > prior_size=nullptr, std::shared_ptr< ParametricGaussian1D > prior_axrat=nullptr, std::shared_ptr< ShapePriorOptions > options=nullptr)
	Construct a ShapePrior from a Parameter and mean_size/std.
	~ShapePrior ()
PriorEvaluation	evaluate (bool calc_jacobians=false, bool normalize_loglike=false) const override
	Evaluate the log likelihood and residual-dependent terms.
std::shared_ptr< ParametricGaussian1D >	get_prior_size () const
std::shared_ptr< ParametricGaussian1D >	get_prior_axrat () const
std::vector< double >	get_loglike_const_terms () const override
	Return the constant terms of the log likelihood (dependent on stddevs only)
void	set_prior_size (std::shared_ptr< ParametricGaussian1D > prior_size)
void	set_prior_axrat (std::shared_ptr< ParametricGaussian1D > prior_axrat)
size_t	size () const override
std::string	repr (bool name_keywords=false, std::string_view namespace_separator=Object::CC_NAMESPACE_SEPARATOR) const override
	Return a full, callable string representation of this.
std::string	str () const override
	Return a brief, human-readable string representation of this.

Static Public Member Functions
static std::string_view	null_str (const std::string_view &namespace_separator)

Static Public Attributes
static constexpr std::string_view	CC_NAMESPACE_SEPARATOR = "::"
	The C++ namespace separator.
static constexpr std::string_view	NULL_STR_GENERAL = "None"
static constexpr std::string_view	PY_NAMESPACE_SEPARATOR = "."

Detailed Description

A two-part prior on the shape of a parametric ellipse.

Note

The size and axis ratio priors are separate and optional.

The size prior applies to the major-axis size.

Definition at line 63 of file shapeprior.h.

Constructor & Destructor Documentation

ShapePrior()

lsst::gauss2d::fit::ShapePrior::ShapePrior ( std::shared_ptr< const ParametricEllipse > ellipse, std::shared_ptr< ParametricGaussian1D > prior_size = nullptr, std::shared_ptr< ParametricGaussian1D > prior_axrat = nullptr, std::shared_ptr< ShapePriorOptions > options = nullptr )

explicit

Construct a ShapePrior from a Parameter and mean_size/std.

deviation.

Parameters

ellipse	The ParametricEllipse to compute a prior for.
mean_size	The mean value of the size prior.
stddev_size	The standard deviation of the size prior.

Definition at line 109 of file shapeprior.cc.

        : _ellipse(std::move(ellipse)),
          _prior_size(std::move(prior_size)),
          _prior_axrat(std::move(prior_axrat)),
          _options(std::move((options == nullptr) ? std::make_shared<ShapePriorOptions>() : options)) {
    if (_ellipse == nullptr) throw std::invalid_argument("ellipse param must not be null");
    double loglike = this->evaluate().loglike;
    if (!std::isfinite(loglike)) {
        throw std::invalid_argument(this->str() + " has non-finite loglike=" + std::to_string(loglike)
                                    + " on init");
    }
}

~ShapePrior()

lsst::gauss2d::fit::ShapePrior::~ShapePrior

(

)

Definition at line 125 of file shapeprior.cc.

{}

Member Function Documentation

evaluate()

PriorEvaluation lsst::gauss2d::fit::ShapePrior::evaluate ( bool calc_jacobians = false, bool normalize_loglike = false ) const

overridevirtual

Evaluate the log likelihood and residual-dependent terms.

Parameters

calc_jacobians	Whether to compute the Jacobian and residual terms.
normalize_loglike	Whether to add the constant (sigma-dependent) factors to the log likehood.

Returns

The result of the evaluation.

Implements lsst::gauss2d::fit::Prior.

Definition at line 127 of file shapeprior.cc.

                                                                              {
    const auto ellipse = lsst::gauss2d::Ellipse(this->_ellipse->get_size_x(), this->_ellipse->get_size_y(),
                                                this->_ellipse->get_rho());
    const auto ellipse_major = lsst::gauss2d::EllipseMajor(ellipse);
 
    double size_maj = ellipse_major.get_r_major();
    double axrat = size_maj == 0 ? 0 : ellipse_major.get_axrat();
 
    if (!(axrat >= 0)) {
        throw std::runtime_error(this->str() + " got invalid axrat=" + std::to_string(axrat));
    }
 
    auto result = PriorEvaluation(0, {}, {}, false);
 
    if (this->_prior_size != nullptr) {
        double size_maj_floor = this->_options->get_size_maj_floor();
        size_maj = sqrt(size_maj * size_maj * axrat + size_maj_floor * size_maj_floor);
        size_maj = _prior_size->get_mean_parameter().get_transform().forward(size_maj);
        double sigma = _prior_size->get_stddev();
        double residual = (size_maj - _prior_size->get_mean_parameter().get_value_transformed()) / sigma;
        if (!std::isfinite(residual)) {
            throw std::runtime_error(this->str() + ".evaluate() got non-finite size residual="
                                     + std::to_string(residual) + " from size_maj=" + std::to_string(size_maj)
                                     + ", _prior_size=" + _prior_size->str());
        }
        result.residuals.emplace_back(residual);
        result.loglike += normalize ? logpdf_norm(residual, 1.0) : -residual * residual / 2.;
    }
 
    if (this->_prior_axrat != nullptr) {
        double axrat_floor = this->_options->get_axrat_floor();
        axrat = sqrt(axrat_floor * axrat_floor + axrat * axrat);
        if (axrat > 1) {
            axrat = 1;
        } else if (!(axrat >= 0)) {
            throw std::runtime_error(this->str() + " got invalid axrat=" + std::to_string(axrat)
                                     + " from axrat_floor=" + std::to_string(axrat_floor));
        }
        const auto& transform_param = _prior_axrat->get_mean_parameter().get_transform();
        axrat = transform_param.forward(axrat);
        double sigma = _prior_axrat->get_stddev();
        double residual = (axrat - _prior_axrat->get_mean_parameter().get_value_transformed()) / sigma;
        if (!std::isfinite(residual)) {
            auto str = this->str();
            throw std::runtime_error(str + ".evaluate() got non-finite axrat residual="
                                     + std::to_string(residual) + " from axrat=" + std::to_string(axrat)
                                     + ", _prior_axrat=" + _prior_axrat->str());
        }
        // RuntimeError('Infinite axis ratio prior residual from q={axrat} and mean, std, f
        // 'logit stretch divisor = {self.axrat_params}')
        result.residuals.emplace_back(residual);
        result.loglike += normalize ? logpdf_norm(residual, 1.0) : -residual * residual / 2.;
    }
 
    if (calc_jacobians) {
        ParamRefs params = nonconsecutive_unique(_ellipse->get_parameters_new());
        for (auto& paramref : params) {
            auto& param = paramref.get();
            double value_init = param.get_value();
            double value_trans = param.get_value_transformed();
            double delta = finite_difference_param(param, _options->get_delta_jacobian());
            double value_new = param.get_value_transformed();
 
            std::vector<double> residuals_old;
            std::vector<double> residuals_new;
            try {
                param.set_value_transformed(value_trans + delta / 2.);
                residuals_new = this->evaluate(false, normalize).residuals;
                param.set_value_transformed(value_trans - delta / 2.);
                residuals_old = this->evaluate(false, normalize).residuals;
            } catch (std::exception& e) {
                param.set_value_transformed(value_new);
                residuals_new = this->evaluate(false, normalize).residuals;
                residuals_old = result.residuals;
            }
            // Return to the old value
            param.set_value(value_init);
            value_new = param.get_value();
            if (value_new != value_init) {
                throw std::runtime_error(this->str() + " could not return " + param.str()
                                         + " to original value=" + to_string_float(value_init) + " (stuck at "
                                         + to_string_float(value_new) + "); check limits");
            }
            std::vector<double> jacobians(result.residuals.size());
            for (size_t idx = 0; idx < result.residuals.size(); ++idx) {
                jacobians[idx] = (residuals_new[idx] - residuals_old[idx]) / delta;
            }
            result.jacobians[paramref] = jacobians;
        }
    }
 
    return result;
}

get_loglike_const_terms()

std::vector< double > lsst::gauss2d::fit::ShapePrior::get_loglike_const_terms ( ) const

overridevirtual

Return the constant terms of the log likelihood (dependent on stddevs only)

Implements lsst::gauss2d::fit::Prior.

Definition at line 225 of file shapeprior.cc.

                                                            {
    return {this->_prior_size == nullptr ? 0 : (LOG_1 - log(this->_prior_size->get_stddev() * SQRT_2_PI)),
            this->_prior_axrat == nullptr ? 0 : (LOG_1 - log(this->_prior_axrat->get_stddev() * SQRT_2_PI))};
}

get_prior_axrat()

std::shared_ptr< ParametricGaussian1D > lsst::gauss2d::fit::ShapePrior::get_prior_axrat

(

)

const

Definition at line 223 of file shapeprior.cc.

{ return _prior_axrat; }

get_prior_size()

std::shared_ptr< ParametricGaussian1D > lsst::gauss2d::fit::ShapePrior::get_prior_size

(

)

const

Definition at line 221 of file shapeprior.cc.

{ return _prior_size; }

null_str()

static std::string_view lsst::gauss2d::Object::null_str ( const std::string_view & namespace_separator )

inlinestaticinherited

Definition at line 49 of file object.h.

                                                                              {
        return namespace_separator == CC_NAMESPACE_SEPARATOR ? "nullptr" : NULL_STR_GENERAL;
    }

repr()

std::string lsst::gauss2d::fit::ShapePrior::repr ( bool name_keywords = false, std::string_view namespace_separator = Object::CC_NAMESPACE_SEPARATOR ) const

overridevirtual

Return a full, callable string representation of this.

Parameters

name_keywords	Whether to prefix arguments with "{name}=", where name is the arg name in the header (as with keyword arguments in Python).
namespace_separator	The string to use to delimit namespaces, i.e. :: in C++ and . in Python.

Returns

A callable string representation of this, which should return an an identical object to this.

Note

The representation with name_keywords=false must be callable in C++. The representation with name_keywords=true should be callable in Python, if there are any bindings.

Implements lsst::gauss2d::Object.

Definition at line 240 of file shapeprior.cc.

                                                                                       {
    return type_name_str<ShapePrior>(false, namespace_separator) + "(" + (name_keywords ? "ellipse=" : "")
           + _ellipse->repr(name_keywords, namespace_separator) + ", " + (name_keywords ? "prior_size=" : "")
           + repr_ptr(_prior_size.get(), name_keywords, namespace_separator) + ", "
           + (name_keywords ? "prior_axrat=" : "")
           + repr_ptr(_prior_axrat.get(), name_keywords, namespace_separator) + ", "
           + (name_keywords ? "options=" : "") + _options->repr(name_keywords, namespace_separator) + ")";
}

set_prior_axrat()

void lsst::gauss2d::fit::ShapePrior::set_prior_axrat

(

std::shared_ptr< ParametricGaussian1D >

prior_axrat

)

Definition at line 234 of file shapeprior.cc.

                                                                                {
    _prior_axrat = prior_axrat;
}

set_prior_size()

void lsst::gauss2d::fit::ShapePrior::set_prior_size

(

std::shared_ptr< ParametricGaussian1D >

prior_size

)

Definition at line 230 of file shapeprior.cc.

                                                                              {
    _prior_size = prior_size;
}

size()

size_t lsst::gauss2d::fit::ShapePrior::size ( ) const

overridevirtual

Implements lsst::gauss2d::fit::Prior.

Definition at line 238 of file shapeprior.cc.

{ return (this->_prior_size != nullptr) + (this->_prior_axrat != nullptr); };

str()

std::string lsst::gauss2d::fit::ShapePrior::str ( ) const

overridevirtual

Return a brief, human-readable string representation of this.

Implements lsst::gauss2d::Object.

Definition at line 249 of file shapeprior.cc.

                                {
    return type_name_str<ShapePrior>(true) + "(ellipse=" + _ellipse->str()
           + ", prior_size=" + str_ptr(_prior_size.get()) + ", prior_axrat=" + str_ptr(_prior_axrat.get())
           + ", options=" + _options->str() + ")";
}

Member Data Documentation

CC_NAMESPACE_SEPARATOR

constexpr std::string_view lsst::gauss2d::Object::CC_NAMESPACE_SEPARATOR = "::"

staticconstexprinherited

The C++ namespace separator.

Definition at line 45 of file object.h.

NULL_STR_GENERAL

constexpr std::string_view lsst::gauss2d::Object::NULL_STR_GENERAL = "None"

staticconstexprinherited

Definition at line 46 of file object.h.

PY_NAMESPACE_SEPARATOR

constexpr std::string_view lsst::gauss2d::Object::PY_NAMESPACE_SEPARATOR = "."

staticconstexprinherited

Definition at line 47 of file object.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/gauss2d_fit/gb58c049af0+d64f4d3760/include/lsst/gauss2d/fit/shapeprior.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/gauss2d_fit/gb58c049af0+d64f4d3760/src/shapeprior.cc