LSSTApplications  19.0.0-10-g4a5fae6+3,19.0.0-10-g920eed2,19.0.0-11-g48a0200+2,19.0.0-18-gfc4e62b+16,19.0.0-2-g3b2f90d+2,19.0.0-2-gd671419+6,19.0.0-20-g5a5a17ab+14,19.0.0-21-g2644856+17,19.0.0-24-g0913cb1,19.0.0-24-g878c510+4,19.0.0-25-g6c8df7140+1,19.0.0-25-gb330496+4,19.0.0-3-g2b32d65+6,19.0.0-3-g8227491+15,19.0.0-3-g9c54d0d+15,19.0.0-3-gca68e65+11,19.0.0-3-gcfc5f51+6,19.0.0-3-ge110943+14,19.0.0-3-ge74d124,19.0.0-30-g9c3fd16+5,19.0.0-4-g06f5963+6,19.0.0-4-g10df615,19.0.0-4-g3d16501+17,19.0.0-4-g4a9c019+6,19.0.0-4-g5a8b323,19.0.0-4-g66397f0+1,19.0.0-4-g8557e14,19.0.0-4-g8964aba+16,19.0.0-4-ge404a01+15,19.0.0-5-g40f3a5a,19.0.0-5-g4db63b3,19.0.0-5-gb9eeb60,19.0.0-5-gfb03ce7+16,19.0.0-6-gbaebbfb+15,19.0.0-61-gec4c6e08+5,19.0.0-7-g039c0b5+15,19.0.0-7-gbea9075+4,19.0.0-7-gc567de5+16,19.0.0-72-g37abf38+2,19.0.0-9-g463f923+15,v20.0.0.rc1
LSSTDataManagementBasePackage
Classes | Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Friends | List of all members
lsst::afw::detection::PeakTable Class Reference

Table class for Peaks in Footprints. More...

#include <Peak.h>

Inheritance diagram for lsst::afw::detection::PeakTable:
lsst::afw::table::BaseTable std::enable_shared_from_this< BaseTable >

Public Types

typedef PeakRecord Record
 
typedef afw::table::ColumnViewT< PeakRecordColumnView
 
typedef afw::table::CatalogT< RecordCatalog
 
typedef afw::table::CatalogT< Record const > ConstCatalog
 

Public Member Functions

 ~PeakTable () override
 
PeakTableoperator= (PeakTable const &)=delete
 
PeakTableoperator= (PeakTable &&)=delete
 
std::shared_ptr< afw::table::IdFactorygetIdFactory ()
 Return the object that generates IDs for the table (may be null). More...
 
std::shared_ptr< afw::table::IdFactory const > getIdFactory () const
 Return the object that generates IDs for the table (may be null). More...
 
void setIdFactory (std::shared_ptr< afw::table::IdFactory > f)
 Switch to a new IdFactory – object that generates IDs for the table (may be null). More...
 
std::shared_ptr< PeakTableclone () const
 Return a polymorphic deep copy of the table. More...
 
std::shared_ptr< PeakRecordmakeRecord ()
 Default-construct an associated record. More...
 
std::shared_ptr< PeakRecordcopyRecord (afw::table::BaseRecord const &other)
 Deep-copy a record, requiring that it have the same schema as this table. More...
 
std::shared_ptr< PeakRecordcopyRecord (afw::table::BaseRecord const &other, afw::table::SchemaMapper const &mapper)
 Deep-copy a record, requiring that it have the same schema as this table. More...
 
std::shared_ptr< daf::base::PropertyListgetMetadata () 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::PropertyListpopMetadata ()
 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...
 
shared_from_this (T... args)
 

Static Public Member Functions

static std::shared_ptr< PeakTablemake (afw::table::Schema const &schema, bool forceNew=false)
 Obtain a table that can be used to create records with given schema. More...
 
static afw::table::Schema makeMinimalSchema ()
 Return a minimal schema for Peak tables and records. More...
 
static bool checkSchema (afw::table::Schema const &other)
 Return true if the given schema is a valid PeakTable schema. More...
 
static afw::table::Key< afw::table::RecordIdgetIdKey ()
 Get keys for standard fields shared by all peaks. More...
 
static afw::table::Key< int > getIxKey ()
 
static afw::table::Key< int > getIyKey ()
 
static afw::table::Key< float > getFxKey ()
 
static afw::table::Key< float > getFyKey ()
 
static afw::table::Key< float > getPeakValueKey ()
 
static std::shared_ptr< BaseTablemake (Schema const &schema)
 Construct a new table. More...
 

Static Public Attributes

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

Protected Member Functions

 PeakTable (afw::table::Schema const &schema, std::shared_ptr< afw::table::IdFactory > const &idFactory)
 
 PeakTable (PeakTable const &other)
 
 PeakTable (PeakTable &&other)
 
std::shared_ptr< afw::table::BaseTable_clone () const override
 Clone implementation with noncovariant return types. More...
 
std::shared_ptr< afw::table::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...
 
virtual void handleAliasChange (std::string const &alias)
 

Friends

class afw::table::io::FitsWriter
 

Detailed Description

Table class for Peaks in Footprints.

Definition at line 102 of file Peak.h.

Member Typedef Documentation

◆ Catalog

Definition at line 106 of file Peak.h.

◆ ColumnView

Definition at line 105 of file Peak.h.

◆ ConstCatalog

Definition at line 107 of file Peak.h.

◆ Record

Definition at line 104 of file Peak.h.

Constructor & Destructor Documentation

◆ ~PeakTable()

lsst::afw::detection::PeakTable::~PeakTable ( )
overridedefault

◆ PeakTable() [1/3]

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

Definition at line 132 of file Peak.cc.

134  : afw::table::BaseTable(schema), _idFactory(idFactory) {}

◆ PeakTable() [2/3]

lsst::afw::detection::PeakTable::PeakTable ( PeakTable const &  other)
protected

Definition at line 136 of file Peak.cc.

137  : afw::table::BaseTable(other),
138  _idFactory(other._idFactory ? other._idFactory->clone() : other._idFactory) {}

◆ PeakTable() [3/3]

lsst::afw::detection::PeakTable::PeakTable ( PeakTable &&  other)
protected

Definition at line 140 of file Peak.cc.

140 : PeakTable(other) {}

Member Function Documentation

◆ _clone()

std::shared_ptr< afw::table::BaseTable > lsst::afw::detection::PeakTable::_clone ( ) const
overrideprotectedvirtual

Clone implementation with noncovariant return types.

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

Definition at line 162 of file Peak.cc.

162  {
163  return std::shared_ptr<PeakTable>(new PeakTable(*this));
164 }

◆ _makeRecord()

std::shared_ptr< afw::table::BaseRecord > lsst::afw::detection::PeakTable::_makeRecord ( )
overrideprotectedvirtual

Default-construct an associated record (protected implementation).

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

Definition at line 166 of file Peak.cc.

166  {
167  auto record = constructRecord<PeakRecord>();
168  if (getIdFactory()) record->setId((*getIdFactory())());
169  return record;
170 }

◆ checkSchema()

static bool lsst::afw::detection::PeakTable::checkSchema ( afw::table::Schema const &  other)
inlinestatic

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

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

Definition at line 145 of file Peak.h.

145  {
146  return other.contains(getMinimalSchema().schema);
147  }

◆ clone()

std::shared_ptr<PeakTable> lsst::afw::detection::PeakTable::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 173 of file Peak.h.

173 { return std::static_pointer_cast<PeakTable>(_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.

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

◆ copyRecord() [1/2]

std::shared_ptr<PeakRecord> lsst::afw::detection::PeakTable::copyRecord ( afw::table::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 179 of file Peak.h.

179  {
180  return std::static_pointer_cast<PeakRecord>(afw::table::BaseTable::copyRecord(other));
181  }

◆ copyRecord() [2/2]

std::shared_ptr<PeakRecord> lsst::afw::detection::PeakTable::copyRecord ( afw::table::BaseRecord const &  other,
afw::table::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 184 of file Peak.h.

185  {
186  return std::static_pointer_cast<PeakRecord>(afw::table::BaseTable::copyRecord(other, mapper));
187  }

◆ 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 113 of file BaseTable.cc.

113  {
114  if (_manager) {
115  return Block::getBufferSize(_schema.getRecordSize(), _manager);
116  } else {
117  return 0;
118  }
119 }

◆ getFxKey()

static afw::table::Key<float> lsst::afw::detection::PeakTable::getFxKey ( )
inlinestatic

Definition at line 167 of file Peak.h.

167 { return getMinimalSchema().fx; }

◆ getFyKey()

static afw::table::Key<float> lsst::afw::detection::PeakTable::getFyKey ( )
inlinestatic

Definition at line 168 of file Peak.h.

168 { return getMinimalSchema().fy; }

◆ getIdFactory() [1/2]

std::shared_ptr<afw::table::IdFactory> lsst::afw::detection::PeakTable::getIdFactory ( )
inline

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

Definition at line 150 of file Peak.h.

150 { return _idFactory; }

◆ getIdFactory() [2/2]

std::shared_ptr<afw::table::IdFactory const> lsst::afw::detection::PeakTable::getIdFactory ( ) const
inline

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

Definition at line 153 of file Peak.h.

153 { return _idFactory; }

◆ getIdKey()

static afw::table::Key<afw::table::RecordId> lsst::afw::detection::PeakTable::getIdKey ( )
inlinestatic

Get keys for standard fields shared by all peaks.

These keys are used to implement getters and setters on PeakRecord.

Definition at line 164 of file Peak.h.

164 { return getMinimalSchema().id; }

◆ getIxKey()

static afw::table::Key<int> lsst::afw::detection::PeakTable::getIxKey ( )
inlinestatic

Definition at line 165 of file Peak.h.

165 { return getMinimalSchema().ix; }

◆ getIyKey()

static afw::table::Key<int> lsst::afw::detection::PeakTable::getIyKey ( )
inlinestatic

Definition at line 166 of file Peak.h.

166 { return getMinimalSchema().iy; }

◆ 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.

79 { return _metadata; }

◆ getPeakValueKey()

static afw::table::Key<float> lsst::afw::detection::PeakTable::getPeakValueKey ( )
inlinestatic

Definition at line 169 of file Peak.h.

169 { return getMinimalSchema().peakValue; }

◆ getSchema()

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

Return the table's schema.

Definition at line 137 of file BaseTable.h.

137 { return _schema; }

◆ handleAliasChange()

virtual void lsst::afw::table::BaseTable::handleAliasChange ( std::string const &  alias)
inlineprotectedvirtualinherited

Reimplemented in lsst::afw::table::SourceTable.

Definition at line 201 of file BaseTable.h.

201 {}

◆ make() [1/2]

std::shared_ptr< PeakTable > lsst::afw::detection::PeakTable::make ( afw::table::Schema const &  schema,
bool  forceNew = false 
)
static

Obtain a table that can be used to create records with given schema.

Parameters
[in]schemaSchema that defines the fields, offsets, and record size for the table.
[in]forceNewIf true, guarantee that the returned PeakTable will be a new one, rather than attempting to reuse an existing PeakTable with the same Schema.

If a PeakTable already exists that uses this Schema, that PeakTable will be returned instead of creating a new one. This is different from how most Record/Table classes work, but it is an important memory optimization for Peaks, for which we expect to have very few distinct Schemas as well as many catalogs (one per Footprint) with a small number of Peaks; we don't want to have a different PeakTable for each one of those catalogs if they all share the same Schema. This behavior can be disabled by setting forceNewTable=true or by cloning an existing table (in both of these cases, the new table will not be reused in the future, either)

Definition at line 98 of file Peak.cc.

98  {
99  typedef std::list<std::weak_ptr<PeakTable> > CachedTableList;
100  static CachedTableList cache;
101  if (!checkSchema(schema)) {
103  "Schema for Peak must contain at least the keys defined by makeMinimalSchema().");
104  }
105  if (forceNewTable) {
107  }
108  CachedTableList::iterator iter = cache.begin();
109  while (iter != cache.end()) {
110  std::shared_ptr<PeakTable> p = iter->lock();
111  if (!p) {
112  iter = cache.erase(iter);
113  } else {
114  if (p->getSchema().compare(schema, afw::table::Schema::IDENTICAL) ==
116  // Move the one we found to the front of the list, so it's easier to find
117  // the same thing repeatedly
118  if (iter != cache.begin()) {
119  cache.splice(cache.begin(), cache, iter);
120  }
121  return p;
122  }
123  ++iter;
124  }
125  }
126  // No match: we create a new table and put it in the cache
128  cache.push_front(newTable);
129  return newTable;
130 }

◆ make() [2/2]

std::shared_ptr< BaseTable > lsst::afw::table::BaseTable::make ( Schema const &  schema)
staticinherited

Construct a new table.

Because BaseTable is an abstract class, this actually returns a hidden trivial subclass (which is associated with a hidden trivial subclass of BaseRecord).

Hiding concrete table and record classes in anonymous namespaces is not required, but it makes it easier to ensure instances are always created within shared_ptrs, and it eliminates some multilateral friending that would otherwise be necessary. In some cases it may also serve as a form of pimpl, keeping class implementation details out of header files.

Definition at line 121 of file BaseTable.cc.

121  {
123 }

◆ makeMinimalSchema()

static afw::table::Schema lsst::afw::detection::PeakTable::makeMinimalSchema ( )
inlinestatic

Return a minimal schema for Peak tables and records.

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

Definition at line 137 of file Peak.h.

137 { return getMinimalSchema().schema; }

◆ makeRecord()

std::shared_ptr<PeakRecord> lsst::afw::detection::PeakTable::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 176 of file Peak.h.

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

◆ operator=() [1/2]

PeakTable& lsst::afw::detection::PeakTable::operator= ( PeakTable &&  )
delete

◆ operator=() [2/2]

PeakTable& lsst::afw::detection::PeakTable::operator= ( PeakTable 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.

85  {
87  _metadata.swap(tmp);
88  return tmp;
89  }

◆ 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 111 of file BaseTable.cc.

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

◆ setIdFactory()

void lsst::afw::detection::PeakTable::setIdFactory ( std::shared_ptr< afw::table::IdFactory f)
inline

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

Definition at line 156 of file Peak.h.

156 { _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.

82 { _metadata = metadata; }

Friends And Related Function Documentation

◆ afw::table::io::FitsWriter

friend class afw::table::io::FitsWriter
friend

Definition at line 216 of file Peak.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:
schema
table::Schema schema
Definition: Amplifier.cc:115
lsst::afw::detection::PeakTable::_clone
std::shared_ptr< afw::table::BaseTable > _clone() const override
Clone implementation with noncovariant return types.
Definition: Peak.cc:162
std::shared_ptr
STL class.
lsst::meas::algorithms.psfSelectionFromMatchList.args
list args
Definition: psfSelectionFromMatchList.py:27
std::list
STL class.
lsst::afw::table::Schema::getRecordSize
int getRecordSize() const
Return the raw size of a record in bytes.
Definition: Schema.h:148
lsst::afw::table::IdFactory::makeSimple
static std::shared_ptr< IdFactory > makeSimple()
Return a simple IdFactory that simply counts from 1.
Definition: IdFactory.cc:70
lsst::afw::detection::PeakTable::getIdFactory
std::shared_ptr< afw::table::IdFactory > getIdFactory()
Return the object that generates IDs for the table (may be null).
Definition: Peak.h:150
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::table::Schema::IDENTICAL
@ IDENTICAL
Everything is the same.
Definition: Schema.h:71
LSST_EXCEPT
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
lsst::afw::detection::PeakTable::checkSchema
static bool checkSchema(afw::table::Schema const &other)
Return true if the given schema is a valid PeakTable schema.
Definition: Peak.h:145
lsst::pex::exceptions::InvalidParameterError
Reports invalid arguments.
Definition: Runtime.h:66
lsst::afw::table::BaseTable::copyRecord
std::shared_ptr< BaseRecord > copyRecord(BaseRecord const &input)
Deep-copy a record, requiring that it have the same schema as this table.
Definition: BaseTable.cc:125
mapper
SchemaMapper * mapper
Definition: SchemaMapper.cc:78
lsst::afw::detection::PeakTable::_makeRecord
std::shared_ptr< afw::table::BaseRecord > _makeRecord() override
Default-construct an associated record (protected implementation).
Definition: Peak.cc:166
lsst::afw::detection::PeakTable::PeakTable
PeakTable(afw::table::Schema const &schema, std::shared_ptr< afw::table::IdFactory > const &idFactory)
Definition: Peak.cc:132
lsst::afw::table::BaseTable::BaseTable
BaseTable(Schema const &schema)
Construct from a schema.
Definition: BaseTable.cc:149
astshim.fitsChanContinued.iter
def iter(self)
Definition: fitsChanContinued.py:88