lsst::gauss2d::fit::Channel Class Reference

An observational channel, usually representing some range of wavelengths of light. More...

#include <channel.h>

Inheritance diagram for lsst::gauss2d::fit::Channel:

Classes
struct	Shared_enabler

Public Types
typedef std::map< std::string, std::shared_ptr< const Channel > >	Registry

Public Member Functions
	Channel (const Channel &)=delete
Channel &	operator= (const Channel &)=delete
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.
const bool	operator< (const Channel &c) const
const bool	operator== (const Channel &c) const
const bool	operator!= (const Channel &c) const

Static Public Member Functions
static void	erase (std::string name)
	Delete a channel with a given name.
static const std::shared_ptr< const Channel >	find_channel (std::string name)
	Find a channel with the given name.
static const std::shared_ptr< const Channel >	get_channel (std::string name)
	Get a channel with the given name, creating it if it doesn't exist.
static std::vector< std::shared_ptr< const Channel > >	get_channels ()
static const std::shared_ptr< const Channel >	NONE_PTR ()
static const Channel &	NONE ()
static std::shared_ptr< Channel >	make (std::string name)
	Construct a new Channel.
static const std::shared_ptr< const Channel >	make_const (std::string name)
	Same as make(), but creating a new Channel.
static std::string_view	null_str (const std::string_view &namespace_separator)

Public Attributes
const std::string	name

Static Public Attributes
static const std::string	NAME_NONE = "None"
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 observational channel, usually representing some range of wavelengths of light.

A Channel is a distinguishing property of an Observation, allowing IntegralModels to define integrals in distinct regions of some parameter space. Channels can represent a physical object such as a filter or more abstract definitions like wavelength/frequency ranges, generic labels like ABC, something inbetween like RGB, or anything else users prefer.

Note

Channels are compared and sorted alphabetically.

Definition at line 29 of file channel.h.

Member Typedef Documentation

Registry

typedef std::map<std::string, std::shared_ptr<const Channel> > lsst::gauss2d::fit::Channel::Registry

Definition at line 31 of file channel.h.

Constructor & Destructor Documentation

Channel()

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

delete

Member Function Documentation

erase()

void lsst::gauss2d::fit::Channel::erase ( std::string name )

static

Delete a channel with a given name.

Parameters

name	The name of the channel to delete

Exceptions

std::invalid_argument	If the channel is the default (NAME_NONE) or non-existent
std::runtime_error	If the channel is referenced by any other objects

Definition at line 51 of file channel.cc.

                                  {
    if (name == NAME_NONE) throw std::invalid_argument("Can't erase the " + NAME_NONE + " Channel");
    const std::shared_ptr<const Channel> channel = Channel::get_channel(name);
    if (channel == nullptr) throw std::invalid_argument("Can't erase non-existent Channel name=" + name);
    size_t use_count = channel.use_count();
    if (use_count < 2) {
        throw std::logic_error("Failed erasing " + channel->str()
                               + " with unexpected use_count=" + std::to_string(use_count));
    } else if (use_count == 2) {
        _registry.erase(name);
    } else {
        throw std::runtime_error("Can't erase " + channel->str()
                                 + " with use_count=" + std::to_string(use_count));
    }
}

find_channel()

const std::shared_ptr< const Channel > lsst::gauss2d::fit::Channel::find_channel ( std::string name )

static

Find a channel with the given name.

Parameters

name	The name of the channel to find

Returns

The Channel is if it exists, or nullptr otherwise

Definition at line 67 of file channel.cc.

                                                                       {
    if (name == NAME_NONE) return NONE_PTR();
    auto channel = _registry.find(name);
    auto found = channel == _registry.end() ? nullptr : channel->second;
    return found;
}

get_channel()

const std::shared_ptr< const Channel > lsst::gauss2d::fit::Channel::get_channel ( std::string name )

static

Get a channel with the given name, creating it if it doesn't exist.

Parameters

name	The name of the channel to get

Returns

The Channel with the given name (created if non-existent)

Definition at line 74 of file channel.cc.

                                                                      {
    auto channel = Channel::find_channel(name);
    if (channel == nullptr) channel = Channel::make(name);
    return channel;
}

get_channels()

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

static

Definition at line 80 of file channel.cc.

                                                              {
    std::vector<std::shared_ptr<const Channel>> vec = {};
    for (const auto &[key, value] : _registry) {
        vec.emplace_back(value);
    }
    vec.emplace_back(NONE_PTR());
    return vec;
}

make()

std::shared_ptr< Channel > lsst::gauss2d::fit::Channel::make ( std::string name )

static

Construct a new Channel.

Parameters

name	The name of the Channel to create

Returns

The new Channel

Definition at line 89 of file channel.cc.

                                                   {
    std::shared_ptr<Channel> c = std::make_shared<Shared_enabler>(name);
    if (name != NAME_NONE) {
        _registry.insert({name, c});
    }
    return c;
}

make_const()

const std::shared_ptr< const Channel > lsst::gauss2d::fit::Channel::make_const ( std::string name )

static

Same as make(), but creating a new Channel.

Definition at line 97 of file channel.cc.

{ return make(name); }

NONE()

const Channel & lsst::gauss2d::fit::Channel::NONE ( )

static

Definition at line 111 of file channel.cc.

{ return *NONE_PTR(); }

NONE_PTR()

const std::shared_ptr< const Channel > lsst::gauss2d::fit::Channel::NONE_PTR ( )

static

Definition at line 106 of file channel.cc.

                                                     {
    static const std::shared_ptr<const Channel> _NONE = Channel::make(Channel::NAME_NONE);
    return _NONE;
}

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!=()

const bool lsst::gauss2d::fit::Channel::operator!=

(

const Channel &

c

)

const

Definition at line 49 of file channel.cc.

{ return !(*this == c); }

operator<()

const bool lsst::gauss2d::fit::Channel::operator<

(

const Channel &

c

)

const

Definition at line 45 of file channel.cc.

{ return name < c.name; }

operator=()

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

delete

operator==()

const bool lsst::gauss2d::fit::Channel::operator==

(

const Channel &

c

)

const

Definition at line 47 of file channel.cc.

{ return name == c.name; }

repr()

std::string lsst::gauss2d::fit::Channel::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 99 of file channel.cc.

                                                                                    {
    return type_name_str<Channel>(false, namespace_separator) + "(" + (name_keywords ? "name=" : "") + name
           + ")";
}

str()

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

overridevirtual

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

Implements lsst::gauss2d::Object.

Definition at line 104 of file channel.cc.

{ return type_name_str<Channel>(true) + "(name=" + name + ")"; }

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.

name

const std::string lsst::gauss2d::fit::Channel::name

Definition at line 66 of file channel.h.

NAME_NONE

const std::string lsst::gauss2d::fit::Channel::NAME_NONE = "None"

inlinestatic

Definition at line 64 of file channel.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-11.0.0/Linux/gauss2d_fit/g199a45376c+0ba108daf9/include/lsst/gauss2d/fit/channel.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-11.0.0/Linux/gauss2d_fit/g199a45376c+0ba108daf9/src/channel.cc