LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Classes | Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
lsst::meas::base::ApertureFluxAlgorithm Class Referenceabstract

Base class for multiple-aperture photometry algorithms. More...

#include <ApertureFlux.h>

Inheritance diagram for lsst::meas::base::ApertureFluxAlgorithm:
lsst::meas::base::SimpleAlgorithm lsst::meas::base::SingleFrameAlgorithm lsst::meas::base::ForcedAlgorithm lsst::meas::base::BaseAlgorithm lsst::meas::base::BaseAlgorithm lsst::meas::base::CircularApertureFluxAlgorithm

Public Types

typedef ApertureFluxControl Control
 
typedef ApertureFluxResult Result
 Result object returned by static methods. More...
 

Public Member Functions

 ApertureFluxAlgorithm (Control const &ctrl, std::string const &name, afw::table::Schema &schema, daf::base::PropertySet &metadata)
 Construct the algorithm and add its fields to the given Schema. More...
 
virtual ~ApertureFluxAlgorithm ()
 
virtual void measure (afw::table::SourceRecord &record, afw::image::Exposure< float > const &exposure) const =0
 Measure the configured apertures on the given image. More...
 
virtual void fail (afw::table::SourceRecord &measRecord, MeasurementError *error=nullptr) const
 Handle an exception thrown by the current algorithm by setting flags in the given record. More...
 
virtual void measureForced (afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure, afw::table::SourceRecord const &refRecord, afw::geom::SkyWcs const &refWcs) const
 Called to measure a single child source in an image. More...
 
virtual void measureNForced (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure, afw::table::SourceCatalog const &refRecord, afw::geom::SkyWcs const &refWcs) const
 Called to simultaneously measure all children in a deblend family, in a single image. More...
 
virtual void measureN (afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure) const
 Called to simultaneously measure all children in a deblend family, in a single image. More...
 
std::string getLogName () const
 

Static Public Member Functions

static FlagDefinitionList const & getFlagDefinitions ()
 
template<typename T >
static Result computeSincFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 Compute the instFlux (and optionally, uncertanties) within an aperture using Sinc photometry. More...
 
template<typename T >
static Result computeSincFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 
template<typename T >
static Result computeNaiveFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 Compute the instFlux (and optionally, uncertanties) within an aperture using naive photometry. More...
 
template<typename T >
static Result computeNaiveFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 
template<typename T >
static Result computeFlux (afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 Compute the instFlux (and optionally, uncertanties) within an aperture using the algorithm determined by its size and the maxSincRadius control parameter. More...
 
template<typename T >
static Result computeFlux (afw::image::MaskedImage< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
 
static std::string makeFieldPrefix (std::string const &name, double radius)
 Construct an appropriate prefix for table fields. More...
 

Static Public Attributes

static unsigned int const N_FLAGS = 3
 
static FlagDefinition const FAILURE = flagDefinitions.addFailureFlag()
 
static FlagDefinition const APERTURE_TRUNCATED
 
static FlagDefinition const SINC_COEFFS_TRUNCATED
 

Protected Member Functions

void copyResultToRecord (Result const &result, afw::table::SourceRecord &record, int index) const
 
FlagHandler const & getFlagHandler (int index) const
 

Protected Attributes

Control const _ctrl
 
SafeCentroidExtractor _centroidExtractor
 
std::string _logName
 

Detailed Description

Base class for multiple-aperture photometry algorithms.

ApertureFluxAlgorithm serves as an intermediate base class for all aperture fluxes, which it assumes have that capability of measuring multiple apertures (even if they are not always configured to do so).

Concrete implementations for single-aperture flux measurements are provided as static methods, as well as a consistent interface and control object for its derived classes. Currently, we only have one derived class, CircularApertureFluxAlgorithm, but in the future we anticipate adding more derived classes for e.g. elliptical apertures, or apertures that are circular in sky coordinates rather than pixel coordinates.

Definition at line 80 of file ApertureFlux.h.

Member Typedef Documentation

◆ Control

Definition at line 89 of file ApertureFlux.h.

◆ Result

Result object returned by static methods.

Definition at line 92 of file ApertureFlux.h.

Constructor & Destructor Documentation

◆ ApertureFluxAlgorithm()

lsst::meas::base::ApertureFluxAlgorithm::ApertureFluxAlgorithm ( Control const &  ctrl,
std::string const &  name,
afw::table::Schema schema,
daf::base::PropertySet metadata 
)
explicit

Construct the algorithm and add its fields to the given Schema.

Definition at line 71 of file ApertureFlux.cc.

75  : _ctrl(ctrl), _centroidExtractor(schema, name) {
76  _keys.reserve(ctrl.radii.size());
77  for (std::size_t i = 0; i < ctrl.radii.size(); ++i) {
78  std::string upperName(name);
79  boost::to_upper(upperName);
80  metadata.add(upperName + "_RADII", ctrl.radii[i]);
82  std::string doc = (boost::format("instFlux within %f-pixel aperture") % ctrl.radii[i]).str();
83  _keys.push_back(Keys(schema, prefix, doc, ctrl.radii[i] <= ctrl.maxSincRadius));
84  }
85 }
table::Key< std::string > name
Definition: Amplifier.cc:116
std::string prefix
Definition: SchemaMapper.cc:72
table::Schema schema
Definition: python.h:134
SafeCentroidExtractor _centroidExtractor
Definition: ApertureFlux.h:199
static std::string makeFieldPrefix(std::string const &name, double radius)
Construct an appropriate prefix for table fields.
Definition: ApertureFlux.cc:57
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
T push_back(T... args)
T reserve(T... args)

◆ ~ApertureFluxAlgorithm()

virtual lsst::meas::base::ApertureFluxAlgorithm::~ApertureFluxAlgorithm ( )
inlinevirtual

Definition at line 163 of file ApertureFlux.h.

163 {}

Member Function Documentation

◆ computeFlux() [1/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeFlux ( afw::image::Image< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Compute the instFlux (and optionally, uncertanties) within an aperture using the algorithm determined by its size and the maxSincRadius control parameter.

This method delegates to computeSincFlux is the minor axis of the aperture is smaller than ctrl.maxSincRadius, and delegates to computeNaiveFlux otherwise.

Parameters
[in]imageImage or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as instFluxes.
[in]ellipseEllipse that defines the outer boundary of the aperture.
[in]ctrlControl object.

Definition at line 223 of file ApertureFlux.cc.

225  {
226  return (afw::geom::ellipses::Axes(ellipse.getCore()).getB() <= ctrl.maxSincRadius)
227  ? computeSincFlux(image, ellipse, ctrl)
228  : computeNaiveFlux(image, ellipse, ctrl);
229 }
static Result computeSincFlux(afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
Compute the instFlux (and optionally, uncertanties) within an aperture using Sinc photometry.
static Result computeNaiveFlux(afw::image::Image< T > const &image, afw::geom::ellipses::Ellipse const &ellipse, Control const &ctrl=Control())
Compute the instFlux (and optionally, uncertanties) within an aperture using naive photometry.
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.

◆ computeFlux() [2/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeFlux ( afw::image::MaskedImage< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Definition at line 232 of file ApertureFlux.cc.

234  {
235  return (afw::geom::ellipses::Axes(ellipse.getCore()).getB() <= ctrl.maxSincRadius)
236  ? computeSincFlux(image, ellipse, ctrl)
237  : computeNaiveFlux(image, ellipse, ctrl);
238 }

◆ computeNaiveFlux() [1/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeNaiveFlux ( afw::image::Image< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Compute the instFlux (and optionally, uncertanties) within an aperture using naive photometry.

The naive algorithm just counts the instFlux in pixels whose centers lie within the aperture, ignoring the effects of sub-pixel aperture boundaries.

Parameters
[in]imageImage or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as instFluxes.
[in]ellipseEllipse that defines the outer boundary of the aperture.

Definition at line 176 of file ApertureFlux.cc.

177  {
178  Result result;
179  afw::geom::ellipses::PixelRegion region(ellipse); // behaves mostly like a Footprint
180  if (!image.getBBox().contains(region.getBBox())) {
182  result.setFlag(FAILURE.number);
183  return result;
184  }
185  result.instFlux = 0;
186  for (afw::geom::ellipses::PixelRegion::Iterator spanIter = region.begin(), spanEnd = region.end();
187  spanIter != spanEnd; ++spanIter) {
188  typename afw::image::Image<T>::x_iterator pixIter =
189  image.x_at(spanIter->getBeginX() - image.getX0(), spanIter->getY() - image.getY0());
190  result.instFlux += std::accumulate(pixIter, pixIter + spanIter->getWidth(), 0.0);
191  }
192  return result;
193 }
py::object result
Definition: _schema.cc:429
T accumulate(T... args)
std::vector< Span >::const_iterator Iterator
Iterator type used by begin() and end().
Definition: PixelRegion.h:50
typename _view_t::x_iterator x_iterator
An iterator for traversing the pixels in a row.
Definition: ImageBase.h:133
static FlagDefinition const FAILURE
Definition: ApertureFlux.h:85
static FlagDefinition const APERTURE_TRUNCATED
Definition: ApertureFlux.h:86
ApertureFluxResult Result
Result object returned by static methods.
Definition: ApertureFlux.h:92

◆ computeNaiveFlux() [2/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeNaiveFlux ( afw::image::MaskedImage< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Definition at line 196 of file ApertureFlux.cc.

198  {
199  Result result;
200  afw::geom::ellipses::PixelRegion region(ellipse); // behaves mostly like a Footprint
201  if (!image.getBBox().contains(region.getBBox())) {
203  result.setFlag(FAILURE.number);
204  return result;
205  }
206  result.instFlux = 0.0;
207  result.instFluxErr = 0.0;
208  for (afw::geom::ellipses::PixelRegion::Iterator spanIter = region.begin(), spanEnd = region.end();
209  spanIter != spanEnd; ++spanIter) {
210  typename afw::image::MaskedImage<T>::Image::x_iterator pixIter = image.getImage()->x_at(
211  spanIter->getBeginX() - image.getX0(), spanIter->getY() - image.getY0());
212  typename afw::image::MaskedImage<T>::Variance::x_iterator varIter = image.getVariance()->x_at(
213  spanIter->getBeginX() - image.getX0(), spanIter->getY() - image.getY0());
214  result.instFlux += std::accumulate(pixIter, pixIter + spanIter->getWidth(), 0.0);
215  // we use this to hold variance as we accumulate...
216  result.instFluxErr += std::accumulate(varIter, varIter + spanIter->getWidth(), 0.0);
217  }
218  result.instFluxErr = std::sqrt(result.instFluxErr); // ...and switch back to sigma here.
219  return result;
220 }
T sqrt(T... args)

◆ computeSincFlux() [1/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeSincFlux ( afw::image::Image< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Compute the instFlux (and optionally, uncertanties) within an aperture using Sinc photometry.

The Sinc algorithm is slower than a naive aperture, but more accurate, in that it correctly handles sub-pixel aperture boundaries on well-sampled data. This improved accuracy is most important for smaller apertures.

Parameters
[in]imageImage or MaskedImage to be measured. If a MaskedImage is provided, uncertainties will be returned as well as instFluxes.
[in]ellipseEllipse that defines the outer boundary of the aperture.
[in]ctrlControl object.

Definition at line 146 of file ApertureFlux.cc.

147  {
148  Result result;
149  std::shared_ptr<afw::image::Image<T> const> cImage = getSincCoeffs<T>(image.getBBox(), ellipse, result, ctrl);
150  if (result.getFlag(APERTURE_TRUNCATED.number)) return result;
151  afw::image::Image<T> subImage(image, cImage->getBBox());
152  result.instFlux =
153  (ndarray::asEigenArray(subImage.getArray()) * ndarray::asEigenArray(cImage->getArray())).sum();
154  return result;
155 }

◆ computeSincFlux() [2/2]

template<typename T >
ApertureFluxAlgorithm::Result lsst::meas::base::ApertureFluxAlgorithm::computeSincFlux ( afw::image::MaskedImage< T > const &  image,
afw::geom::ellipses::Ellipse const &  ellipse,
Control const &  ctrl = Control() 
)
static

Definition at line 158 of file ApertureFlux.cc.

160  {
161  Result result;
162  std::shared_ptr<afw::image::Image<T> const> cImage = getSincCoeffs<T>(image.getBBox(), ellipse, result, ctrl);
163  if (result.getFlag(APERTURE_TRUNCATED.number)) return result;
164  afw::image::MaskedImage<T> subImage(image, cImage->getBBox(afw::image::PARENT), afw::image::PARENT);
165  result.instFlux = (ndarray::asEigenArray(subImage.getImage()->getArray()) *
166  ndarray::asEigenArray(cImage->getArray()))
167  .sum();
168  result.instFluxErr =
169  std::sqrt((ndarray::asEigenArray(subImage.getVariance()->getArray()).template cast<T>() *
170  ndarray::asEigenArray(cImage->getArray()).square())
171  .sum());
172  return result;
173 }

◆ copyResultToRecord()

void lsst::meas::base::ApertureFluxAlgorithm::copyResultToRecord ( Result const &  result,
afw::table::SourceRecord record,
int  index 
) const
protected

Definition at line 96 of file ApertureFlux.cc.

97  {
98  record.set(_keys[index].instFluxKey, result);
99  if (result.getFlag(FAILURE.number)) {
100  _keys[index].flags.setValue(record, FAILURE.number, true);
101  }
102  if (result.getFlag(APERTURE_TRUNCATED.number)) {
103  _keys[index].flags.setValue(record, APERTURE_TRUNCATED.number, true);
104  }
105  if (result.getFlag(SINC_COEFFS_TRUNCATED.number)) {
106  _keys[index].flags.setValue(record, SINC_COEFFS_TRUNCATED.number, true);
107  }
108 }
static FlagDefinition const SINC_COEFFS_TRUNCATED
Definition: ApertureFlux.h:87

◆ fail()

void lsst::meas::base::ApertureFluxAlgorithm::fail ( afw::table::SourceRecord measRecord,
MeasurementError error = nullptr 
) const
virtual

Handle an exception thrown by the current algorithm by setting flags in the given record.

fail() is called by the measurement framework when an exception is allowed to propagate out of one the algorithm's measure() methods. It should generally set both a general failure flag for the algorithm as well as a specific flag indicating the error condition, if possible. To aid in this, if the exception was an instance of MeasurementError, it will be passed in, carrying information about what flag to set.

An algorithm can also to chose to set flags within its own measure() methods, and then just return, rather than throw an exception. However, fail() should be implemented even when all known failure modes do not throw exceptions, to ensure that unexpected exceptions thrown in lower-level code are properly handled.

Implements lsst::meas::base::BaseAlgorithm.

Definition at line 87 of file ApertureFlux.cc.

87  {
88  // This should only get called in the case of completely unexpected failures, so it's not terrible
89  // that we just set the general failure flags for all radii here instead of trying to figure out
90  // which ones we've already done. Any known failure modes are handled inside measure().
91  for (std::size_t i = 0; i < _ctrl.radii.size(); ++i) {
92  _keys[i].flags.handleFailure(measRecord, error);
93  }
94 }
std::vector< double > radii
"Radius (in pixels) of apertures." ;
Definition: ApertureFlux.h:53
T size(T... args)

◆ getFlagDefinitions()

FlagDefinitionList const & lsst::meas::base::ApertureFluxAlgorithm::getFlagDefinitions ( )
static

Definition at line 49 of file ApertureFlux.cc.

49 { return flagDefinitions; }

◆ getFlagHandler()

FlagHandler const& lsst::meas::base::ApertureFluxAlgorithm::getFlagHandler ( int  index) const
inlineprotected

Definition at line 196 of file ApertureFlux.h.

196 { return _keys[index].flags; }

◆ getLogName()

std::string lsst::meas::base::BaseAlgorithm::getLogName ( ) const
inlineinherited

Definition at line 66 of file Algorithm.h.

66 { return _logName; }

◆ makeFieldPrefix()

std::string lsst::meas::base::ApertureFluxAlgorithm::makeFieldPrefix ( std::string const &  name,
double  radius 
)
static

Construct an appropriate prefix for table fields.

Given a plugin name (e.g. base_CircularApertureFlux) and an aperture radius (e.g. 12 pixels) return an appropriate prefix for table fields to contain the measurement results (e.g. base_CircularApertureFlux_12_0). Table fields can then be created named <prefix>_instFlux, <prefix>_instFluxErr, etc.

Parameters
[in]pluginNameName of measurement plugin.
[in]radiusAperture radius (pixels).
Returns
Table field name prefix.

Definition at line 57 of file ApertureFlux.cc.

57  {
58  std::string prefix = (boost::format("%s_%.1f") % name % radius).str();
59  return boost::replace_all_copy(prefix, ".", "_");
60 }

◆ measure()

virtual void lsst::meas::base::ApertureFluxAlgorithm::measure ( afw::table::SourceRecord record,
afw::image::Exposure< float > const &  exposure 
) const
pure virtual

Measure the configured apertures on the given image.

Python plugins will delegate to this method.

Parameters
[in,out]recordRecord used to save outputs and retrieve positions.
[in]exposureImage to be measured.

Implements lsst::meas::base::SingleFrameAlgorithm.

Implemented in lsst::meas::base::CircularApertureFluxAlgorithm.

◆ measureForced()

virtual void lsst::meas::base::SimpleAlgorithm::measureForced ( afw::table::SourceRecord measRecord,
afw::image::Exposure< float > const &  exposure,
afw::table::SourceRecord const &  refRecord,
afw::geom::SkyWcs const &  refWcs 
) const
inlinevirtualinherited

Called to measure a single child source in an image.

Before this method is called, all neighbors will be replaced with noise, using the outputs of the deblender. Outputs should be saved in the given SourceRecord, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

Implements lsst::meas::base::ForcedAlgorithm.

Reimplemented in lsst::meas::extensions::photometryKron::KronFluxAlgorithm.

Definition at line 172 of file Algorithm.h.

175  {
176  measure(measRecord, exposure);
177  }
virtual void measure(afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure) const =0
Called to measure a single child source in an image.

◆ measureN()

void lsst::meas::base::SingleFrameAlgorithm::measureN ( afw::table::SourceCatalog const &  measCat,
afw::image::Exposure< float > const &  exposure 
) const
virtualinherited

Called to simultaneously measure all children in a deblend family, in a single image.

Outputs should be saved in the given SourceCatalog, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

The default implementation simply throws an exception, indicating that simultaneous measurement is not supported.

Definition at line 31 of file Algorithm.cc.

32  {
33  throw LSST_EXCEPT(pex::exceptions::LogicError, "measureN not implemented for this algorithm");
34 }
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48

◆ measureNForced()

virtual void lsst::meas::base::SimpleAlgorithm::measureNForced ( afw::table::SourceCatalog const &  measCat,
afw::image::Exposure< float > const &  exposure,
afw::table::SourceCatalog const &  refRecord,
afw::geom::SkyWcs const &  refWcs 
) const
inlinevirtualinherited

Called to simultaneously measure all children in a deblend family, in a single image.

Outputs should be saved in the given SourceCatalog, which can also be used to obtain centroid (see SafeCentroidExtractor) and shape (see SafeShapeExtractor) information.

The default implementation simply throws an exception, indicating that simultaneous measurement is not supported.

Reimplemented from lsst::meas::base::ForcedAlgorithm.

Definition at line 179 of file Algorithm.h.

182  {
183  measureN(measCat, exposure);
184  }
virtual void measureN(afw::table::SourceCatalog const &measCat, afw::image::Exposure< float > const &exposure) const
Called to simultaneously measure all children in a deblend family, in a single image.
Definition: Algorithm.cc:31

Member Data Documentation

◆ _centroidExtractor

SafeCentroidExtractor lsst::meas::base::ApertureFluxAlgorithm::_centroidExtractor
protected

Definition at line 199 of file ApertureFlux.h.

◆ _ctrl

Control const lsst::meas::base::ApertureFluxAlgorithm::_ctrl
protected

Definition at line 198 of file ApertureFlux.h.

◆ _logName

std::string lsst::meas::base::BaseAlgorithm::_logName
protectedinherited

Definition at line 69 of file Algorithm.h.

◆ APERTURE_TRUNCATED

FlagDefinition const lsst::meas::base::ApertureFluxAlgorithm::APERTURE_TRUNCATED
static
Initial value:
=
flagDefinitions.add("flag_apertureTruncated", "aperture did not fit within measurement image")

Definition at line 86 of file ApertureFlux.h.

◆ FAILURE

FlagDefinition const lsst::meas::base::ApertureFluxAlgorithm::FAILURE = flagDefinitions.addFailureFlag()
static

Definition at line 85 of file ApertureFlux.h.

◆ N_FLAGS

unsigned int const lsst::meas::base::ApertureFluxAlgorithm::N_FLAGS = 3
static

Definition at line 84 of file ApertureFlux.h.

◆ SINC_COEFFS_TRUNCATED

FlagDefinition const lsst::meas::base::ApertureFluxAlgorithm::SINC_COEFFS_TRUNCATED
static
Initial value:
= flagDefinitions.add(
"flag_sincCoeffsTruncated", "full sinc coefficient image did not fit within measurement image")

Definition at line 87 of file ApertureFlux.h.


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