lsst::afw::table::SourceTable Class Reference

Table class that contains measurements made on a single exposure. More...

#include <Source.h>

Inheritance diagram for lsst::afw::table::SourceTable:

Public Types
using	Record = SourceRecord
using	ColumnView = SourceColumnViewT< SourceRecord >
using	Catalog = SortedCatalogT< Record >
using	ConstCatalog = SortedCatalogT< const Record >

Public Member Functions
std::shared_ptr< SourceTable >	clone () const
	Return a polymorphic deep copy of the table. More...
std::shared_ptr< SourceRecord >	makeRecord ()
	Default-construct an associated record. More...
std::shared_ptr< SourceRecord >	copyRecord (BaseRecord const &other)
	Deep-copy a record, requiring that it have the same schema as this table. More...
std::shared_ptr< SourceRecord >	copyRecord (BaseRecord const &other, SchemaMapper const &mapper)
	Deep-copy a record, requiring that it have the same schema as this table. More...
FluxSlotDefinition const &	getPsfFluxSlot () const
void	definePsfFlux (std::string const &name)
	Set the measurement used for the PsfFlux slot. More...
FluxSlotDefinition const &	getModelFluxSlot () const
void	defineModelFlux (std::string const &name)
	Set the measurement used for the ModelFlux slot. More...
FluxSlotDefinition const &	getApFluxSlot () const
void	defineApFlux (std::string const &name)
	Set the measurement used for the ApFlux slot. More...
FluxSlotDefinition const &	getGaussianFluxSlot () const
void	defineGaussianFlux (std::string const &name)
	Set the measurement used for the GaussianFlux slot. More...
FluxSlotDefinition const &	getCalibFluxSlot () const
void	defineCalibFlux (std::string const &name)
	Set the measurement used for the CalibFlux slot. More...
CentroidSlotDefinition const &	getCentroidSlot () const
void	defineCentroid (std::string const &name)
	Set the measurement used for the Centroid slot. More...
ShapeSlotDefinition const &	getShapeSlot () const
void	defineShape (std::string const &name)
	Set the measurement used for the Shape slot. More...
SourceTable &	operator= (SourceTable const &)=delete
SourceTable &	operator= (SourceTable &&)=delete
std::shared_ptr< IdFactory >	getIdFactory ()
	Return the object that generates IDs for the table (may be null). More...
std::shared_ptr< IdFactory const >	getIdFactory () const
	Return the object that generates IDs for the table (may be null). More...
void	setIdFactory (std::shared_ptr< IdFactory > f)
	Switch to a new IdFactory – object that generates IDs for the table (may be null). More...
std::shared_ptr< daf::base::PropertyList >	getMetadata () const
	Return the flexible metadata associated with the table. May be null. More...
void	setMetadata (std::shared_ptr< daf::base::PropertyList > const &metadata)
	Set the flexible metadata associated with the table. May be null. More...
std::shared_ptr< daf::base::PropertyList >	popMetadata ()
	Return the metadata and set the internal metadata to a null pointer. More...
Schema	getSchema () const
	Return the table's schema. More...
void	preallocate (std::size_t nRecords)
	Allocate contiguous space for new records in advance. More...
std::size_t	getBufferSize () const
	Return the number of additional records space has been already been allocated for. More...
T	shared_from_this (T... args)

Static Public Member Functions
static std::shared_ptr< SourceTable >	make (Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
	Construct a new table. More...
static std::shared_ptr< SourceTable >	make (Schema const &schema)
	Construct a new table. More...
static Schema	makeMinimalSchema ()
	Return a minimal schema for Source tables and records. More...
static bool	checkSchema (Schema const &other)
	Return true if the given schema is a valid SourceTable schema. More...
static Key< RecordId >	getParentKey ()
	Key for the parent ID. More...
static Key< RecordId >	getIdKey ()
	Get keys for standard fields shared by all references. More...
static CoordKey	getCoordKey ()
	Key for the celestial coordinates. More...

Static Public Attributes
static int	nRecordsPerBlock = 100
	Number of records in each memory block. More...

Protected Member Functions
	SourceTable (Schema const &schema, std::shared_ptr< IdFactory > const &idFactory)
	SourceTable (SourceTable const &other)
	SourceTable (SourceTable &&other)
void	handleAliasChange (std::string const &alias) override
std::shared_ptr< BaseTable >	_clone () const override
	Clone implementation with noncovariant return types. More...
std::shared_ptr< BaseRecord >	_makeRecord () override
	Default-construct an associated record (protected implementation). More...
template<typename RecordT , typename ... Args>
std::shared_ptr< RecordT >	constructRecord (Args &&...args)
	Helper function that must be used by all _makeRecord overrides to actually construct records. More...

Friends
class	io::FitsWriter
class	SourceRecord

Detailed Description

Table class that contains measurements made on a single exposure.

Definition at line 217 of file Source.h.

Member Typedef Documentation

Catalog

using lsst::afw::table::SourceTable::Catalog = SortedCatalogT<Record>

Definition at line 221 of file Source.h.

ColumnView

using lsst::afw::table::SourceTable::ColumnView = SourceColumnViewT<SourceRecord>

Definition at line 220 of file Source.h.

ConstCatalog

using lsst::afw::table::SourceTable::ConstCatalog = SortedCatalogT<const Record>

Definition at line 222 of file Source.h.

Record

using lsst::afw::table::SourceTable::Record = SourceRecord

Definition at line 219 of file Source.h.

Constructor & Destructor Documentation

SourceTable() [1/3]

lsst::afw::table::SourceTable::SourceTable ( Schema const &  schema, std::shared_ptr< IdFactory > const &  idFactory  )

protected

Definition at line 391 of file Source.cc.

        : SimpleTable(schema, idFactory), _slots(schema) {}

SourceTable() [2/3]

lsst::afw::table::SourceTable::SourceTable ( SourceTable const &  other )

protecteddefault

SourceTable() [3/3]

lsst::afw::table::SourceTable::SourceTable ( SourceTable &&  other )

protected

Definition at line 396 of file Source.cc.

: SourceTable(other) {}

Member Function Documentation

_clone()

std::shared_ptr< BaseTable > lsst::afw::table::SourceTable::_clone ( ) const

overrideprotectedvirtual

Clone implementation with noncovariant return types.

Reimplemented from lsst::afw::table::SimpleTable.

Definition at line 419 of file Source.cc.

                                                   {
    return std::shared_ptr<SourceTable>(new SourceTable(*this));
}

_makeRecord()

std::shared_ptr< BaseRecord > lsst::afw::table::SourceTable::_makeRecord ( )

overrideprotectedvirtual

Default-construct an associated record (protected implementation).

Reimplemented from lsst::afw::table::SimpleTable.

Definition at line 423 of file Source.cc.

                                                   {
    auto record = constructRecord<SourceRecord>();
    if (getIdFactory()) record->setId((*getIdFactory())());
    return record;
}

checkSchema()

static bool lsst::afw::table::SourceTable::checkSchema ( Schema const &  other )

inlinestatic

Return true if the given schema is a valid SourceTable schema.

This will always be true if the given schema was originally constructed using makeMinimalSchema(), and will rarely be true otherwise.

Definition at line 270 of file Source.h.

{ return other.contains(getMinimalSchema().schema); }

clone()

std::shared_ptr<SourceTable> lsst::afw::table::SourceTable::clone ( ) const

inline

Return a polymorphic deep copy of the table.

Derived classes should reimplement by static-casting the output of _clone to a pointer-to-derived to simulate covariant return types.

Cloning a table does not clone its associated records; the new table produced by clone() does not have any associated records.

Definition at line 276 of file Source.h.

{ return std::static_pointer_cast<SourceTable>(_clone()); }

constructRecord()

template<typename RecordT , typename ... Args>

std::shared_ptr< RecordT > lsst::afw::table::BaseTable::constructRecord ( Args &&...  args )

protectedinherited

Helper function that must be used by all _makeRecord overrides to actually construct records.

Use of this function is enforced by the fact that Record::ConstructionToken can only be created by BaseTable, and is only ever constructed inside this method.

This function expects Record subclasses to have a constructor signature of the form

Record(ConstructionToken const &, detail::RecordData &&, Args && ...);

Definition at line 227 of file BaseRecord.h.

                                                                 {
    return std::make_shared<RecordT>(BaseRecord::ConstructionToken(0), _makeNewRecordData(),
                                     std::forward<Args>(args)...);
}

copyRecord() [1/2]

std::shared_ptr<SourceRecord> lsst::afw::table::SourceTable::copyRecord ( BaseRecord const &  other )

inline

Deep-copy a record, requiring that it have the same schema as this table.

Regardless of the type or associated table of the input record, the type of the output record will be the type associated with this table and the record instance will be associated with this table.

Allowing derived-class records to be constructed from base-class records could be considered a form of type-slicing, but because we already demand that all records be constructable from nothing but a table, this isn't anything new.

Derived classes should reimplement by static-casting the output of BaseTable::copyRecord to the appropriate BaseRecord subclass.

This is implemented using makeRecord and calling record.assign on the results; override those to change the behavior.

Definition at line 284 of file Source.h.

                                                                    {
        return std::static_pointer_cast<SourceRecord>(BaseTable::copyRecord(other));
    }

copyRecord() [2/2]

std::shared_ptr<SourceRecord> lsst::afw::table::SourceTable::copyRecord ( BaseRecord const &  other, SchemaMapper const &  mapper  )

inline

Deep-copy a record, requiring that it have the same schema as this table.

Regardless of the type or associated table of the input record, the type of the output record will be the type associated with this table and the record instance will be associated with this table.

Allowing derived-class records to be constructed from base-class records could be considered a form of type-slicing, but because we already demand that all records be constructable from nothing but a table, this isn't anything new.

Derived classes should reimplement by static-casting the output of BaseTable::copyRecord to the appropriate BaseRecord subclass.

This is implemented using makeRecord and calling record.assign on the results; override those to change the behavior.

Definition at line 289 of file Source.h.

                                                                                                {
        return std::static_pointer_cast<SourceRecord>(BaseTable::copyRecord(other, mapper));
    }

defineApFlux()

void lsst::afw::table::SourceTable::defineApFlux ( std::string const &  name )

inline

Set the measurement used for the ApFlux slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_ApFlux" alias to point to the given field name prefix. See FluxSlotDefinition for more information.

Definition at line 328 of file Source.h.

                                             {
        getSchema().getAliasMap()->set(getApFluxSlot().getAlias(), name);
    }

defineCalibFlux()

void lsst::afw::table::SourceTable::defineCalibFlux ( std::string const &  name )

inline

Set the measurement used for the CalibFlux slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_CalibFlux" alias to point to the given field name prefix. See FluxSlotDefinition for more information.

Definition at line 354 of file Source.h.

                                                {
        getSchema().getAliasMap()->set(getCalibFluxSlot().getAlias(), name);
    }

defineCentroid()

void lsst::afw::table::SourceTable::defineCentroid ( std::string const &  name )

inline

Set the measurement used for the Centroid slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_Centroid" alias to point to the given field name prefix. See CentroidSlotDefinition for more information.

Definition at line 367 of file Source.h.

                                               {
        getSchema().getAliasMap()->set(getCentroidSlot().getAlias(), name);
    }

defineGaussianFlux()

void lsst::afw::table::SourceTable::defineGaussianFlux ( std::string const &  name )

inline

Set the measurement used for the GaussianFlux slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_GaussianFlux" alias to point to the given field name prefix. See FluxSlotDefinition for more information.

Definition at line 341 of file Source.h.

                                                   {
        getSchema().getAliasMap()->set(getGaussianFluxSlot().getAlias(), name);
    }

defineModelFlux()

void lsst::afw::table::SourceTable::defineModelFlux ( std::string const &  name )

inline

Set the measurement used for the ModelFlux slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_ModelFlux" alias to point to the given field name prefix. See FluxSlotDefinition for more information.

Definition at line 315 of file Source.h.

                                                {
        getSchema().getAliasMap()->set(getModelFluxSlot().getAlias(), name);
    }

definePsfFlux()

void lsst::afw::table::SourceTable::definePsfFlux ( std::string const &  name )

inline

Set the measurement used for the PsfFlux slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_PsfFlux" alias to point to the given field name prefix. See FluxSlotDefinition for more information.

Definition at line 302 of file Source.h.

                                              {
        getSchema().getAliasMap()->set(getPsfFluxSlot().getAlias(), name);
    }

defineShape()

void lsst::afw::table::SourceTable::defineShape ( std::string const &  name )

inline

Set the measurement used for the Shape slot.

The definitions for slots are actually managed by the Schema object, and its associated AliasMap, so this simply sets the "slot_Shape" alias to point to the given field name prefix. See ShapeSlotDefinition for more information.

Definition at line 380 of file Source.h.

                                            {
        getSchema().getAliasMap()->set(getShapeSlot().getAlias(), name);
    }

getApFluxSlot()

FluxSlotDefinition const& lsst::afw::table::SourceTable::getApFluxSlot ( ) const

inline

Definition at line 319 of file Source.h.

{ return _slots.defApFlux; }

getBufferSize()

std::size_t lsst::afw::table::BaseTable::getBufferSize ( ) const

inherited

Return the number of additional records space has been already been allocated for.

Unlike std::vector::capacity, this does not factor in existing records in any way.

Definition at line 112 of file BaseTable.cc.

                                         {
    if (_manager) {
        return Block::getBufferSize(_schema.getRecordSize(), _manager);
    } else {
        return 0;
    }
}

getCalibFluxSlot()

FluxSlotDefinition const& lsst::afw::table::SourceTable::getCalibFluxSlot ( ) const

inline

Definition at line 345 of file Source.h.

{ return _slots.defCalibFlux; }

getCentroidSlot()

CentroidSlotDefinition const& lsst::afw::table::SourceTable::getCentroidSlot ( ) const

inline

Definition at line 358 of file Source.h.

{ return _slots.defCentroid; }

getCoordKey()

static CoordKey lsst::afw::table::SimpleTable::getCoordKey ( )

inlinestaticinherited

Key for the celestial coordinates.

Definition at line 172 of file Simple.h.

{ return getMinimalSchema().coord; }

getGaussianFluxSlot()

FluxSlotDefinition const& lsst::afw::table::SourceTable::getGaussianFluxSlot ( ) const

inline

Definition at line 332 of file Source.h.

{ return _slots.defGaussianFlux; }

getIdFactory() [1/2]

std::shared_ptr<IdFactory> lsst::afw::table::SimpleTable::getIdFactory ( )

inlineinherited

Return the object that generates IDs for the table (may be null).

Definition at line 155 of file Simple.h.

{ return _idFactory; }

getIdFactory() [2/2]

std::shared_ptr<IdFactory const> lsst::afw::table::SimpleTable::getIdFactory ( ) const

inlineinherited

Return the object that generates IDs for the table (may be null).

Definition at line 158 of file Simple.h.

{ return _idFactory; }

getIdKey()

static Key<RecordId> lsst::afw::table::SimpleTable::getIdKey ( )

inlinestaticinherited

Get keys for standard fields shared by all references.

These keys are used to implement getters and setters on SimpleRecord. Key for the unique ID.

Definition at line 170 of file Simple.h.

{ return getMinimalSchema().id; }

getMetadata()

std::shared_ptr<daf::base::PropertyList> lsst::afw::table::BaseTable::getMetadata ( ) const

inlineinherited

Return the flexible metadata associated with the table. May be null.

Definition at line 79 of file BaseTable.h.

{ return _metadata; }

getModelFluxSlot()

FluxSlotDefinition const& lsst::afw::table::SourceTable::getModelFluxSlot ( ) const

inline

Definition at line 306 of file Source.h.

{ return _slots.defModelFlux; }

getParentKey()

static Key<RecordId> lsst::afw::table::SourceTable::getParentKey ( )

inlinestatic

Key for the parent ID.

Definition at line 273 of file Source.h.

{ return getMinimalSchema().parent; }

getPsfFluxSlot()

FluxSlotDefinition const& lsst::afw::table::SourceTable::getPsfFluxSlot ( ) const

inline

Definition at line 293 of file Source.h.

{ return _slots.defPsfFlux; }

getSchema()

Schema lsst::afw::table::BaseTable::getSchema ( ) const

inlineinherited

Return the table's schema.

Definition at line 137 of file BaseTable.h.

{ return _schema; }

getShapeSlot()

ShapeSlotDefinition const& lsst::afw::table::SourceTable::getShapeSlot ( ) const

inline

Definition at line 371 of file Source.h.

{ return _slots.defShape; }

handleAliasChange()

void lsst::afw::table::SourceTable::handleAliasChange ( std::string const &  alias )

overrideprotectedvirtual

Reimplemented from lsst::afw::table::BaseTable.

Definition at line 398 of file Source.cc.

                                                          {
    if (alias.compare(0, 4, "slot") != 0) {
        return;
    }
    _slots.handleAliasChange(alias, getSchema());
}

make() [1/2]

static std::shared_ptr<SourceTable> lsst::afw::table::SourceTable::make ( Schema const &  schema )

inlinestatic

Construct a new table.

Parameters

[in]

schema

Schema that defines the fields, offsets, and record size for the table.

This overload sets the ID factory to IdFactory::makeSimple().

Definition at line 244 of file Source.h.

                                                                 {
        return make(schema, IdFactory::makeSimple());
    }

make() [2/2]

std::shared_ptr< SourceTable > lsst::afw::table::SourceTable::make ( Schema const &  schema, std::shared_ptr< IdFactory > const &  idFactory  )

static

Construct a new table.

Parameters

[in]	schema	Schema that defines the fields, offsets, and record size for the table.
[in]	idFactory	Factory class to generate record IDs when they are not explicitly given. If null, record IDs will default to zero.

Note that not passing an IdFactory at all will call the other override of make(), which will set the ID factory to IdFactory::makeSimple().

Definition at line 382 of file Source.cc.

                                                                                          {
    if (!checkSchema(schema)) {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "Schema for Source must contain at least the keys defined by getMinimalSchema().");
    }
    return std::shared_ptr<SourceTable>(new SourceTable(schema, idFactory));
}

makeMinimalSchema()

static Schema lsst::afw::table::SourceTable::makeMinimalSchema ( )

inlinestatic

Return a minimal schema for Source tables and records.

The returned schema can and generally should be modified further, but many operations on sources will assume that at least the fields provided by this routine are present.

Keys for the standard fields added by this routine can be obtained from other static member functions of the SourceTable class.

Definition at line 258 of file Source.h.

                                      {
        Schema r = getMinimalSchema().schema;
        r.disconnectAliases();
        return r;
    }

makeRecord()

std::shared_ptr<SourceRecord> lsst::afw::table::SourceTable::makeRecord ( )

inline

Default-construct an associated record.

Derived classes should reimplement by static-casting the output of _makeRecord to the appropriate BaseRecord subclass to simulate covariant return types.

Definition at line 279 of file Source.h.

                                             {
        return std::static_pointer_cast<SourceRecord>(_makeRecord());
    }

operator=() [1/2]

SourceTable& lsst::afw::table::SourceTable::operator= ( SourceTable &&  )

delete

operator=() [2/2]

SourceTable& lsst::afw::table::SourceTable::operator= ( SourceTable const &  )

delete

popMetadata()

std::shared_ptr<daf::base::PropertyList> lsst::afw::table::BaseTable::popMetadata ( )

inlineinherited

Return the metadata and set the internal metadata to a null pointer.

Definition at line 85 of file BaseTable.h.

                                                     {
        std::shared_ptr<daf::base::PropertyList> tmp;
        _metadata.swap(tmp);
        return tmp;
    }

preallocate()

void lsst::afw::table::BaseTable::preallocate ( std::size_t  nRecords )

inherited

Allocate contiguous space for new records in advance.

If a contiguous memory block for at least n additional records has already been allocated, this is a no-op. If not, a new block will be allocated, and any remaining space on the old block will go to waste; this ensures the new records will be allocated contiguously. Note that "wasted" memory is not leaked; it will be deallocated along with any records created from that block when those records go out of scope.

Note that unlike std::vector::reserve, this does not factor in existing records in any way; nRecords refers to a number of new records to reserve space for.

Definition at line 110 of file BaseTable.cc.

{ Block::preallocate(_schema.getRecordSize(), n, _manager); }

setIdFactory()

void lsst::afw::table::SimpleTable::setIdFactory ( std::shared_ptr< IdFactory >  f )

inlineinherited

Switch to a new IdFactory – object that generates IDs for the table (may be null).

Definition at line 161 of file Simple.h.

{ _idFactory = f; }

setMetadata()

void lsst::afw::table::BaseTable::setMetadata ( std::shared_ptr< daf::base::PropertyList > const &  metadata )

inlineinherited

Set the flexible metadata associated with the table. May be null.

Definition at line 82 of file BaseTable.h.

{ _metadata = metadata; }

Friends And Related Function Documentation

io::FitsWriter

friend class io::FitsWriter

friend

Definition at line 411 of file Source.h.

SourceRecord

friend class SourceRecord

friend

Definition at line 412 of file Source.h.

Member Data Documentation

nRecordsPerBlock

int lsst::afw::table::BaseTable::nRecordsPerBlock = 100

staticinherited

Number of records in each memory block.

Definition at line 76 of file BaseTable.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/include/lsst/afw/table/Source.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/src/table/Source.cc