lsst::gauss2d::fit::FractionalIntegralModel Class Reference

An IntegralModel that returns a Parameter-dependent fraction of the flux of another IntegralModel. More...

#include <fractionalintegralmodel.h>

Inheritance diagram for lsst::gauss2d::fit::FractionalIntegralModel:

Classes
struct	Shared_enabler

Public Types
typedef std::pair< std::reference_wrapper< const Channel >, std::shared_ptr< ProperFractionParameterD > >	ChannelIntegralParameterD
typedef std::vector< ChannelIntegralParameterD >	Data

Public Member Functions
	FractionalIntegralModel (const FractionalIntegralModel &)=delete
FractionalIntegralModel &	operator= (const FractionalIntegralModel &)=delete
	~FractionalIntegralModel ()
std::shared_ptr< ProperFractionParameterD >	at (const Channel &channel)
std::shared_ptr< const ProperFractionParameterD >	at (const Channel &channel) const
Data::iterator	begin () noexcept
Data::const_iterator	cbegin () const noexcept
Data::iterator	end () noexcept
Data::const_iterator	cend () const noexcept
std::vector< std::reference_wrapper< const Channel > >	get_channels () const override
	Get the set of channels this instance is applicable for.
const IntegralModel &	get_parent_model () const
double	get_integral (const Channel &channel) const override
	Get the value of the integral in a single Channel.
std::vector< std::pair< ParamBaseCRef, ExtraParamFactorValues > >	get_integral_derivative_factors (const Channel &channel) const override
	Return the partial derivative of the model w.r.t.
double	get_integral_remainder (const Channel &channel) const
ProperFractionParameterD &	get_parameter_frac (const Channel &channel) const
ParamRefs &	get_parameters (ParamRefs &params, ParamFilter *filter=nullptr) const override
	Add Parameter refs matching the filter to a vector, in order.
ParamCRefs &	get_parameters_const (ParamCRefs &params, ParamFilter *filter=nullptr) const override
	Same as get_parameters(), but for const refs.
bool	is_final () const
size_t	size () const
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.
ParamRefs	get_parameters_new (ParamFilter *filter=nullptr) const
	Same as get_parameters(), but returning a new vector.
ParamCRefs	get_parameters_const_new (ParamFilter *filter=nullptr) const
	Same as get_parameters_const(), but returning a new vector.

Static Public Member Functions
static std::shared_ptr< FractionalIntegralModel >	find_model (const IntegralModel &model)
	Find the FractionalIntegralModel that depends on a given IntegralModel, if any.
static std::shared_ptr< FractionalIntegralModel >	make (std::optional< const Data > data, std::shared_ptr< const IntegralModel > model, bool is_final=false)
	Construct a FractionalIntegralModel and add to registry.
static const std::shared_ptr< const FractionalIntegralModel >	make_const (std::optional< const Data > data, std::shared_ptr< const IntegralModel > model, bool is_final=false)
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

An IntegralModel that returns a Parameter-dependent fraction of the flux of another IntegralModel.

FractionalIntegralModel instances can be chained but are registered to enforce having at most one dependent FractionalIntegralModel. Chains should end in a single fixed ProperFractionParameter of value 1; this is not yet fully enforced.

Note

For longer chains, a single ProperFractionParameter of value 1 will render all downstream models zero-valued, regardless of their own ProperFractionParameter values. Consider setting Limits to prevent such situations if they become problematic.

Definition at line 30 of file fractionalintegralmodel.h.

Member Typedef Documentation

ChannelIntegralParameterD

typedef std::pair<std::reference_wrapper<const Channel>, std::shared_ptr<ProperFractionParameterD> > lsst::gauss2d::fit::FractionalIntegralModel::ChannelIntegralParameterD

Definition at line 33 of file fractionalintegralmodel.h.

Data

typedef std::vector<ChannelIntegralParameterD> lsst::gauss2d::fit::FractionalIntegralModel::Data

Definition at line 34 of file fractionalintegralmodel.h.

Constructor & Destructor Documentation

FractionalIntegralModel()

lsst::gauss2d::fit::FractionalIntegralModel::FractionalIntegralModel ( const FractionalIntegralModel & )

explicitdelete

~FractionalIntegralModel()

lsst::gauss2d::fit::FractionalIntegralModel::~FractionalIntegralModel

(

)

Definition at line 71 of file fractionalintegralmodel.cc.

{};

Member Function Documentation

at() [1/2]

std::shared_ptr< ProperFractionParameterD > lsst::gauss2d::fit::FractionalIntegralModel::at

(

const Channel &

channel

)

Definition at line 73 of file fractionalintegralmodel.cc.

                                                                                          {
    return _map.at(channel);
}

at() [2/2]

std::shared_ptr< const ProperFractionParameterD > lsst::gauss2d::fit::FractionalIntegralModel::at

(

const Channel &

channel

)

const

Definition at line 76 of file fractionalintegralmodel.cc.

                                                                                                      {
    return _map.at(channel);
}

begin()

FractionalIntegralModel::Data::iterator lsst::gauss2d::fit::FractionalIntegralModel::begin ( )

noexcept

Definition at line 88 of file fractionalintegralmodel.cc.

                                                                                     {
    return _data.begin();
}

cbegin()

FractionalIntegralModel::Data::const_iterator lsst::gauss2d::fit::FractionalIntegralModel::cbegin ( ) const

noexcept

Definition at line 91 of file fractionalintegralmodel.cc.

                                                                                                  {
    return _data.begin();
}

cend()

FractionalIntegralModel::Data::const_iterator lsst::gauss2d::fit::FractionalIntegralModel::cend ( ) const

noexcept

Definition at line 98 of file fractionalintegralmodel.cc.

                                                                                                {
    return _data.cend();
}

end()

FractionalIntegralModel::Data::iterator lsst::gauss2d::fit::FractionalIntegralModel::end ( )

noexcept

Definition at line 95 of file fractionalintegralmodel.cc.

                                                                                   {
    return _data.end();
}

find_model()

static std::shared_ptr< FractionalIntegralModel > lsst::gauss2d::fit::FractionalIntegralModel::find_model ( const IntegralModel & model )

inlinestatic

Find the FractionalIntegralModel that depends on a given IntegralModel, if any.

Parameters

model

The IntegralModel to search for

Returns

The FractionalIntegralModel that depends on model, or nullptr if none

Definition at line 56 of file fractionalintegralmodel.h.

                                                                                         {
        const auto found = _registry_rev.find(model);
        return (found == _registry_rev.end()) ? nullptr : (*found).second.lock();
    }

get_channels()

std::vector< std::reference_wrapper< const Channel > > lsst::gauss2d::fit::FractionalIntegralModel::get_channels ( ) const

overridevirtual

Get the set of channels this instance is applicable for.

Note

Implementers must return a set (all unique items). This cannot be enforced (yet).

Implements lsst::gauss2d::fit::Chromatic.

Definition at line 102 of file fractionalintegralmodel.cc.

                                                                                           {
    std::vector<std::reference_wrapper<const Channel>> rval = {};
    for (auto &datum : _data) rval.emplace_back(datum.first);
    return rval;
}

get_integral()

double lsst::gauss2d::fit::FractionalIntegralModel::get_integral ( const Channel & channel ) const

overridevirtual

Get the value of the integral in a single Channel.

Implements lsst::gauss2d::fit::IntegralModel.

Definition at line 115 of file fractionalintegralmodel.cc.

                                                                         {
    return _map.at(channel)->get_value() * (_get_integral_remainder(_parent.get(), *_model, channel));
}

get_integral_derivative_factors()

std::vector< std::pair< ParamBaseCRef, ExtraParamFactorValues > > lsst::gauss2d::fit::FractionalIntegralModel::get_integral_derivative_factors ( const Channel & channel ) const

overridevirtual

Return the partial derivative of the model w.r.t.

each metaparameter.

This is generally needed only for nonlinear Parameter instances.

Parameters

channel

The Channel to return derivatives for.

Returns

A vector of Parameter/derivative pairs, with values ordered as specified in GaussianEvaluator (L, sigma_x, sigma_y).

Implements lsst::gauss2d::fit::IntegralModel.

Definition at line 120 of file fractionalintegralmodel.cc.

                                                                                     {
    const auto &frac = *(this->_map.at(channel));
    /*
        For a model with no parent:
        gauss2d will evaluate dmodel/dweight_comp
        Fitters will want dmodel/dfrac
 
        frac = weight_comp/weight_total
        dfrac/dweight_comp = 1/weight_total
        dweight_comp = dfrac*weight_total
 
        dmodel/d_frac = weight_total*dmodel/dweight_comp
 
        With a parent:
 
        parent: weight_comp_parent = weight_total*frac_parent
        child1: weight_comp_child1 = weight_total*(1 - frac_parent)
        ...
        childN: weight_comp_childN = weight_total*(1 - frac_parent)...*(1-frac_childNminus1)
 
        dmodel/dfrac_parent = weight_total*(1 - frac_parent)*dmodel/dweight_comp
                            = -weight_total*dmodel/dweight_comp
 
        i.e. there are N fraction parameters dependent on dmodel/dweight_comp for children.
        (excluding the fixed fraction for an is_final child)
    */
    if (_parent == nullptr) {
        return {{frac, {_model->get_integral(channel), 0., 0.}}};
    }
    auto factors = _parent->get_integral_derivative_factors(channel);
    if (is_final()) {
        /*
            The last component's fraction is fixed, but it has an integral of
            (1 - frac_previous)*integral_remaining, the derivative of which
            w.r.t. frac_revious is -1*integral_remaining.
         */
        factors.back().second[0] *= -1.;
    } else {
        // TODO: Check this if/when it's ever enabled
        factors.push_back({frac, {factors.back().second[0], 0., 0.}});
    }
    return factors;
}

get_integral_remainder()

double lsst::gauss2d::fit::FractionalIntegralModel::get_integral_remainder

(

const Channel &

channel

)

const

Definition at line 164 of file fractionalintegralmodel.cc.

                                                                                   {
    return (1. - this->at(channel)->get_value()) * _get_integral_remainder(_parent.get(), *_model, channel);
}

get_parameter_frac()

ProperFractionParameterD & lsst::gauss2d::fit::FractionalIntegralModel::get_parameter_frac

(

const Channel &

channel

)

const

Definition at line 168 of file fractionalintegralmodel.cc.

                                                                                                  {
    return *(_map.at(channel));
}

get_parameters()

ParamRefs & lsst::gauss2d::fit::FractionalIntegralModel::get_parameters ( ParamRefs & params, ParamFilter * filter = nullptr ) const

overridevirtual

Add Parameter refs matching the filter to a vector, in order.

Parameters

params	The vector to add to.
filter	The filter to apply to this Object's parameters.

Returns

A ref to params (for method chaining)

Implements lsst::gauss2d::fit::Parametric.

Definition at line 172 of file fractionalintegralmodel.cc.

                                                                                               {
    _model->get_parameters(params, filter);
    // Don't return the n_channels fixed frac=1 parameters at the end
    const size_t n_p_max = _data.size() - (this->is_final() ? this->get_channels().size() : 0);
    size_t i = 0;
    for (auto &p : _data) {
        if (i++ == n_p_max) break;
        insert_param_channel(p.first, *p.second, params, filter);
    }
    return params;
}

get_parameters_const()

ParamCRefs & lsst::gauss2d::fit::FractionalIntegralModel::get_parameters_const ( ParamCRefs & params, ParamFilter * filter = nullptr ) const

overridevirtual

Same as get_parameters(), but for const refs.

Implements lsst::gauss2d::fit::Parametric.

Definition at line 184 of file fractionalintegralmodel.cc.

                                                                                                       {
    _model->get_parameters_const(params, filter);
    const size_t n_p_max = _data.size() - (this->is_final() ? this->get_channels().size() : 0);
    size_t i = 0;
    for (const auto &p : _data) {
        if (i++ == n_p_max) break;
        insert_param_channel(p.first, *p.second, params, filter);
    }
    return params;
}

get_parameters_const_new()

ParamCRefs lsst::gauss2d::fit::Parametric::get_parameters_const_new ( ParamFilter * filter = nullptr ) const

inlineinherited

Same as get_parameters_const(), but returning a new vector.

Definition at line 33 of file parametric.h.

                                                                             {
        ParamCRefs params{};
        get_parameters_const(params, filter);
        return params;
    }

get_parameters_new()

ParamRefs lsst::gauss2d::fit::Parametric::get_parameters_new ( ParamFilter * filter = nullptr ) const

inlineinherited

Same as get_parameters(), but returning a new vector.

Definition at line 27 of file parametric.h.

                                                                      {
        ParamRefs params{};
        get_parameters(params, filter);
        return params;
    }

get_parent_model()

const IntegralModel & lsst::gauss2d::fit::FractionalIntegralModel::get_parent_model

(

)

const

Definition at line 108 of file fractionalintegralmodel.cc.

{ return *_model; }

is_final()

bool lsst::gauss2d::fit::FractionalIntegralModel::is_final

(

)

const

Definition at line 195 of file fractionalintegralmodel.cc.

{ return _is_final; }

make()

std::shared_ptr< FractionalIntegralModel > lsst::gauss2d::fit::FractionalIntegralModel::make ( std::optional< const Data > data, std::shared_ptr< const IntegralModel > model, bool is_final = false )

static

Construct a FractionalIntegralModel and add to registry.

Parameters

data	The map of ProperFractionParameter instances for each channel.
model	The IntegralModel that ProperFractionParameter instances multiply by.
is_final	Whether these fractions are the last in the chain.

Note

Input parameters are validated and will throw exceptions if invalid, e.g. if data and model do not cover the same channels.

Returns

A new FractionalIntegralModel instance

Definition at line 230 of file fractionalintegralmodel.cc.

                                                                                               {
    std::shared_ptr<FractionalIntegralModel> ptr = std::make_shared<Shared_enabler>(data, model, is_final);
    _registry.insert({*ptr, *model});
    FractionalIntegralModel::_registry_rev.insert({*model, ptr});
    return ptr;
}

make_const()

const std::shared_ptr< const FractionalIntegralModel > lsst::gauss2d::fit::FractionalIntegralModel::make_const ( std::optional< const Data > data, std::shared_ptr< const IntegralModel > model, bool is_final = false )

static

Definition at line 238 of file fractionalintegralmodel.cc.

                                                                                               {
    return make(data, model, is_final);
}

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;
    }

operator=()

FractionalIntegralModel & lsst::gauss2d::fit::FractionalIntegralModel::operator= ( const FractionalIntegralModel & )

delete

repr()

std::string lsst::gauss2d::fit::FractionalIntegralModel::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 199 of file fractionalintegralmodel.cc.

                                                                                                    {
    std::string s = type_name_str<FractionalIntegralModel>(false, namespace_separator) + "("
                    + (name_keywords ? "data={" : "{");
    for (const auto &datum : _data) {
        s += datum.first.get().repr(name_keywords, namespace_separator) + ": "
             + datum.second->repr(name_keywords, namespace_separator) + ",";
    }
    return s + "})";
}

size()

size_t lsst::gauss2d::fit::FractionalIntegralModel::size

(

)

const

Definition at line 197 of file fractionalintegralmodel.cc.

{ return _data.size(); }

str()

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

overridevirtual

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

Implements lsst::gauss2d::Object.

Definition at line 209 of file fractionalintegralmodel.cc.

                                             {
    std::string s = type_name_str<FractionalIntegralModel>(true) + "(data={";
    for (const auto &datum : _data) {
        s += datum.first.get().str() + ": " + datum.second->str() + ",";
    }
    s += "}, model=" + _model->str() + ", is_final=" + std::to_string(_is_final) + ")";
    return s;
}

Member Data Documentation

CC_NAMESPACE_SEPARATOR

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

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

staticconstexprinherited

Definition at line 46 of file object.h.

PY_NAMESPACE_SEPARATOR

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-10.0.0/Linux64/gauss2d_fit/gb58c049af0+f03b321e39/include/lsst/gauss2d/fit/fractionalintegralmodel.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/gauss2d_fit/gb58c049af0+f03b321e39/src/fractionalintegralmodel.cc