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
Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Attributes | List of all members
lsst::ip::diffim::PsfDipoleFlux Class Reference

Implementation of Psf dipole flux. More...

#include <DipoleAlgorithms.h>

Inheritance diagram for lsst::ip::diffim::PsfDipoleFlux:
lsst::ip::diffim::DipoleFluxAlgorithm lsst::meas::base::SimpleAlgorithm lsst::meas::base::SingleFrameAlgorithm lsst::meas::base::ForcedAlgorithm lsst::meas::base::BaseAlgorithm lsst::meas::base::BaseAlgorithm

Public Types

typedef PsfDipoleFluxControl Control
 
typedef meas::base::FluxResultKey ResultKey
 

Public Member Functions

 PsfDipoleFlux (PsfDipoleFluxControl const &ctrl, std::string const &name, afw::table::Schema &schema)
 
std::pair< double, int > chi2 (afw::table::SourceRecord &source, afw::image::Exposure< float > const &exposure, double negCenterX, double negCenterY, double negFlux, double posCenterX, double poCenterY, double posFlux) const
 
void measure (afw::table::SourceRecord &measRecord, afw::image::Exposure< float > const &exposure) const
 Called to measure a single child source in an image. More...
 
void fail (afw::table::SourceRecord &measRecord, meas::base::MeasurementError *error=NULL) const
 Handle an exception thrown by the current algorithm by setting flags in the given record. More...
 
ResultKey const & getPositiveKeys () const
 Return the standard flux keys registered by this algorithm. More...
 
ResultKey const & getNegativeKeys () const
 
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 meas::base::FlagDefinitionList const & getFlagDefinitions ()
 

Static Public Attributes

static meas::base::FlagDefinition const FAILURE = dipoleFluxFlagDefinitions.addFailureFlag("general failure flag, set if anything went wrong")
 
static meas::base::FlagDefinition const POS_FLAG = dipoleFluxFlagDefinitions.add("pos_flag", "failure flag for positive, set if anything went wrong")
 
static meas::base::FlagDefinition const NEG_FLAG = dipoleFluxFlagDefinitions.add("neg_flag", "failure flag for negative, set if anything went wrong")
 

Protected Attributes

meas::base::FluxResultKey _fluxResultKey
 
meas::base::FlagHandler _flagHandler
 
ResultKey _positiveKeys
 
ResultKey _negativeKeys
 
std::string _logName
 

Detailed Description

Implementation of Psf dipole flux.

Definition at line 289 of file DipoleAlgorithms.h.

Member Typedef Documentation

◆ Control

Definition at line 292 of file DipoleAlgorithms.h.

◆ ResultKey

Definition at line 131 of file DipoleAlgorithms.h.

Constructor & Destructor Documentation

◆ PsfDipoleFlux()

lsst::ip::diffim::PsfDipoleFlux::PsfDipoleFlux ( PsfDipoleFluxControl const &  ctrl,
std::string const &  name,
afw::table::Schema schema 
)
inline

Definition at line 294 of file DipoleAlgorithms.h.

294  :
295  DipoleFluxAlgorithm(ctrl, name, schema, "jointly fitted psf flux counts"),
296  _ctrl(ctrl),
297  _chi2dofKey(schema.addField<float>(name+"_chi2dof",
298  "chi2 per degree of freedom of fit"))
299  {
300  meas::base::CentroidResultKey::addFields(schema, name+"_pos_centroid", "psf fitted center of positive lobe", meas::base::SIGMA_ONLY);
301  meas::base::CentroidResultKey::addFields(schema, name+"_neg_centroid", "psf fitted center of negative lobe", meas::base::SIGMA_ONLY);
302  meas::base::CentroidResultKey::addFields(schema, name+"_centroid", "average of negative and positive lobe positions", meas::base::SIGMA_ONLY);
303  _posCentroid = meas::base::CentroidResultKey(schema[name+"_pos_centroid"]);
304  _negCentroid = meas::base::CentroidResultKey(schema[name+"_neg_centroid"]);
305  _avgCentroid = meas::base::CentroidResultKey(schema[name+"_centroid"]);
306  }
table::Key< std::string > name
Definition: Amplifier.cc:116
table::Schema schema
Definition: python.h:134
DipoleFluxAlgorithm(Control const &ctrl, std::string const &name, afw::table::Schema &schema, std::string const &doc)
static CentroidResultKey addFields(afw::table::Schema &schema, std::string const &name, std::string const &doc, UncertaintyEnum uncertainty)
Add the appropriate fields to a Schema, and return a CentroidResultKey that manages them.
@ SIGMA_ONLY
Only the diagonal elements of the covariance matrix are provided.
Definition: constants.h:45

Member Function Documentation

◆ chi2()

std::pair< double, int > lsst::ip::diffim::PsfDipoleFlux::chi2 ( afw::table::SourceRecord source,
afw::image::Exposure< float > const &  exposure,
double  negCenterX,
double  negCenterY,
double  negFlux,
double  posCenterX,
double  poCenterY,
double  posFlux 
) const

Definition at line 351 of file DipoleAlgorithms.cc.

356  {
357 
358  geom::Point2D negCenter(negCenterX, negCenterY);
359  geom::Point2D posCenter(posCenterX, posCenterY);
360 
361  std::shared_ptr<afw::detection::Footprint const> footprint = source.getFootprint();
362 
363  /*
364  * Fit for the superposition of Psfs at the two centroids.
365  */
366  std::shared_ptr<afwDet::Psf const> psf = exposure.getPsf();
367  std::shared_ptr<afwImage::Image<afwMath::Kernel::Pixel>> negPsf = psf->computeImage(negCenter);
368  std::shared_ptr<afwImage::Image<afwMath::Kernel::Pixel>> posPsf = psf->computeImage(posCenter);
369 
370  afwImage::Image<double> negModel(footprint->getBBox());
371  afwImage::Image<double> posModel(footprint->getBBox());
372  afwImage::Image<float> data(*(exposure.getMaskedImage().getImage()),footprint->getBBox());
373  afwImage::Image<afwImage::VariancePixel> var(*(exposure.getMaskedImage().getVariance()),
374  footprint->getBBox());
375 
376  geom::Box2I negPsfBBox = negPsf->getBBox();
377  geom::Box2I posPsfBBox = posPsf->getBBox();
378  geom::Box2I negModelBBox = negModel.getBBox();
379  geom::Box2I posModelBBox = posModel.getBBox();
380 
381  // Portion of the negative Psf that overlaps the model
382  int negXmin = std::max(negPsfBBox.getMinX(), negModelBBox.getMinX());
383  int negYmin = std::max(negPsfBBox.getMinY(), negModelBBox.getMinY());
384  int negXmax = std::min(negPsfBBox.getMaxX(), negModelBBox.getMaxX());
385  int negYmax = std::min(negPsfBBox.getMaxY(), negModelBBox.getMaxY());
386  geom::Box2I negBBox = geom::Box2I(geom::Point2I(negXmin, negYmin),
387  geom::Point2I(negXmax, negYmax));
388  afwImage::Image<afwMath::Kernel::Pixel> negSubim(*negPsf, negBBox);
389  afwImage::Image<double> negModelSubim(negModel, negBBox);
390  negModelSubim += negSubim;
391 
392  // Portion of the positive Psf that overlaps the model
393  int posXmin = std::max(posPsfBBox.getMinX(), posModelBBox.getMinX());
394  int posYmin = std::max(posPsfBBox.getMinY(), posModelBBox.getMinY());
395  int posXmax = std::min(posPsfBBox.getMaxX(), posModelBBox.getMaxX());
396  int posYmax = std::min(posPsfBBox.getMaxY(), posModelBBox.getMaxY());
397  geom::Box2I posBBox = geom::Box2I(geom::Point2I(posXmin, posYmin),
398  geom::Point2I(posXmax, posYmax));
399  afwImage::Image<afwMath::Kernel::Pixel> posSubim(*posPsf, posBBox);
400  afwImage::Image<double> posModelSubim(posModel, posBBox);
401  posModelSubim += posSubim;
402 
403  negModel *= negFlux; // scale negative model to image
404  posModel *= posFlux; // scale positive model to image
405  afwImage::Image<double> residuals(negModel, true); // full model contains negative lobe...
406  residuals += posModel; // plus positive lobe...
407  residuals -= data; // minus the data...
408  residuals *= residuals; // squared...
409  residuals /= var; // divided by the variance : [(model-data)/sigma]**2
411  double chi2 = stats.getValue(afwMath::SUM);
412  int nPix = stats.getValue(afwMath::NPOINT);
413  return std::pair<double,int>(chi2, nPix);
414 }
char * data
Definition: BaseRecord.cc:61
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:51
A class to evaluate image statistics.
Definition: Statistics.h:220
double getValue(Property const prop=NOTHING) const
Return the value of the desired property (if specified in the constructor)
Definition: Statistics.cc:1047
An integer coordinate rectangle.
Definition: Box.h:55
int getMinY() const noexcept
Definition: Box.h:158
int getMinX() const noexcept
Definition: Box.h:157
int getMaxX() const noexcept
Definition: Box.h:161
int getMaxY() const noexcept
Definition: Box.h:162
std::pair< double, int > chi2(afw::table::SourceRecord &source, afw::image::Exposure< float > const &exposure, double negCenterX, double negCenterY, double negFlux, double posCenterX, double poCenterY, double posFlux) const
T max(T... args)
T min(T... args)
const char * source()
Source function that allows astChannel to source from a Stream.
Definition: Stream.h:224
Statistics makeStatistics(lsst::afw::image::Image< Pixel > const &img, lsst::afw::image::Mask< image::MaskPixel > const &msk, int const flags, StatisticsControl const &sctrl=StatisticsControl())
Handle a watered-down front-end to the constructor (no variance)
Definition: Statistics.h:359
@ SUM
find sum of pixels in the image
Definition: Statistics.h:77
@ NPOINT
number of sample points
Definition: Statistics.h:65
Key< int > psf
Definition: Exposure.cc:65

◆ fail()

void lsst::ip::diffim::PsfDipoleFlux::fail ( afw::table::SourceRecord measRecord,
meas::base::MeasurementError error = NULL 
) 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 512 of file DipoleAlgorithms.cc.

512  {
513  _flagHandler.handleFailure(measRecord, error);
514 }
void handleFailure(afw::table::BaseRecord &record, MeasurementError const *error=nullptr) const
Handle an expected or unexpected Exception thrown by a measurement algorithm.
Definition: FlagHandler.cc:76

◆ getFlagDefinitions()

meas::base::FlagDefinitionList const & lsst::ip::diffim::DipoleFluxAlgorithm::getFlagDefinitions ( )
staticinherited

Definition at line 65 of file DipoleAlgorithms.cc.

65  {
66  return dipoleFluxFlagDefinitions;
67 }

◆ getLogName()

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

Definition at line 66 of file Algorithm.h.

66 { return _logName; }

◆ getNegativeKeys()

ResultKey const& lsst::ip::diffim::DipoleFluxAlgorithm::getNegativeKeys ( ) const
inlineinherited

Definition at line 134 of file DipoleAlgorithms.h.

◆ getPositiveKeys()

ResultKey const& lsst::ip::diffim::DipoleFluxAlgorithm::getPositiveKeys ( ) const
inlineinherited

Return the standard flux keys registered by this algorithm.

Definition at line 133 of file DipoleAlgorithms.h.

◆ measure()

void lsst::ip::diffim::PsfDipoleFlux::measure ( afw::table::SourceRecord measRecord,
afw::image::Exposure< float > const &  exposure 
) const
virtual

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::SingleFrameAlgorithm.

Definition at line 416 of file DipoleAlgorithms.cc.

419  {
420 
421  typedef afw::image::Exposure<float>::MaskedImageT MaskedImageT;
422 
423  std::shared_ptr<afw::detection::Footprint const> footprint = source.getFootprint();
424  if (!footprint) {
425  throw LSST_EXCEPT(pex::exceptions::RuntimeError,
426  (boost::format("No footprint for source %d") % source.getId()).str());
427  }
428 
429  afw::detection::PeakCatalog peakCatalog = afw::detection::PeakCatalog(footprint->getPeaks());
430 
431  if (peakCatalog.size() == 0) {
432  throw LSST_EXCEPT(pex::exceptions::RuntimeError,
433  (boost::format("No peak for source %d") % source.getId()).str());
434  }
435  else if (peakCatalog.size() == 1) {
436  // No deblending to do
437  return;
438  }
439 
440  // For N>=2, just measure the brightest-positive and brightest-negative
441  // peaks. peakCatalog is automatically ordered by peak flux, with the most
442  // positive one (brightest) being first
443  afw::detection::PeakRecord const& positivePeak = peakCatalog.front();
444  afw::detection::PeakRecord const& negativePeak = peakCatalog.back();
445 
446  // Set up fit parameters and param names
447  ROOT::Minuit2::MnUserParameters fitPar;
448 
449  fitPar.Add((boost::format("P%d")%NEGCENTXPAR).str(), negativePeak.getFx(), _ctrl.stepSizeCoord);
450  fitPar.Add((boost::format("P%d")%NEGCENTYPAR).str(), negativePeak.getFy(), _ctrl.stepSizeCoord);
451  fitPar.Add((boost::format("P%d")%NEGFLUXPAR).str(), negativePeak.getPeakValue(), _ctrl.stepSizeFlux);
452  fitPar.Add((boost::format("P%d")%POSCENTXPAR).str(), positivePeak.getFx(), _ctrl.stepSizeCoord);
453  fitPar.Add((boost::format("P%d")%POSCENTYPAR).str(), positivePeak.getFy(), _ctrl.stepSizeCoord);
454  fitPar.Add((boost::format("P%d")%POSFLUXPAR).str(), positivePeak.getPeakValue(), _ctrl.stepSizeFlux);
455 
456  // Create the minuit object that knows how to minimise our functor
457  //
458  MinimizeDipoleChi2 minimizerFunc(*this, source, exposure);
459  minimizerFunc.setErrorDef(_ctrl.errorDef);
460 
461  //
462  // tell minuit about it
463  //
464  ROOT::Minuit2::MnMigrad migrad(minimizerFunc, fitPar);
465 
466  //
467  // And let it loose
468  //
469  ROOT::Minuit2::FunctionMinimum min = migrad(_ctrl.maxFnCalls);
470 
471  float minChi2 = min.Fval();
472  bool const isValid = min.IsValid() && std::isfinite(minChi2);
473 
474  if (true || isValid) { // calculate coeffs even in minuit is unhappy
475 
476  /* I need to call chi2 one more time to grab nPix to calculate chi2/dof.
477  Turns out that the Minuit operator method has to be const, and the
478  measurement _apply method has to be const, so I can't store nPix as a
479  private member variable anywhere. Consted into a corner.
480  */
481  std::pair<double,int> fit = chi2(source, exposure,
482  min.UserState().Value(NEGCENTXPAR),
483  min.UserState().Value(NEGCENTYPAR),
484  min.UserState().Value(NEGFLUXPAR),
485  min.UserState().Value(POSCENTXPAR),
486  min.UserState().Value(POSCENTYPAR),
487  min.UserState().Value(POSFLUXPAR));
488  double evalChi2 = fit.first;
489  int nPix = fit.second;
490 
491  std::shared_ptr<geom::Point2D> minNegCentroid(new geom::Point2D(min.UserState().Value(NEGCENTXPAR),
492  min.UserState().Value(NEGCENTYPAR)));
493  source.set(getNegativeKeys().getInstFlux(), min.UserState().Value(NEGFLUXPAR));
494  source.set(getNegativeKeys().getInstFluxErr(), min.UserState().Error(NEGFLUXPAR));
495 
496  std::shared_ptr<geom::Point2D> minPosCentroid(new geom::Point2D(min.UserState().Value(POSCENTXPAR),
497  min.UserState().Value(POSCENTYPAR)));
498  source.set(getPositiveKeys().getInstFlux(), min.UserState().Value(POSFLUXPAR));
499  source.set(getPositiveKeys().getInstFluxErr(), min.UserState().Error(POSFLUXPAR));
500 
501  source.set(_chi2dofKey, evalChi2 / (nPix - minimizerFunc.getNpar()));
502  source.set(_negCentroid.getX(), minNegCentroid->getX());
503  source.set(_negCentroid.getY(), minNegCentroid->getY());
504  source.set(_posCentroid.getX(), minPosCentroid->getX());
505  source.set(_posCentroid.getY(), minPosCentroid->getY());
506  source.set(_avgCentroid.getX(), 0.5*(minNegCentroid->getX() + minPosCentroid->getX()));
507  source.set(_avgCentroid.getY(), 0.5*(minNegCentroid->getY() + minPosCentroid->getY()));
508 
509  }
510 }
int min
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
MaskedImage< float, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > MaskedImageT
Definition: Exposure.h:74
ResultKey const & getNegativeKeys() const
ResultKey const & getPositiveKeys() const
Return the standard flux keys registered by this algorithm.
float stepSizeCoord
"Default initial step size for coordinates in non-linear fitter" ;
double errorDef
"How many sigma the error bars of the non-linear fitter represent" ;
float stepSizeFlux
"Default initial step size for flux in non-linear fitter" ;
int maxFnCalls
"Maximum function calls for non-linear fitter; 0 = unlimited" ;
afw::table::Key< CentroidElement > getY() const
Return a Key for the y coordinate.
afw::table::Key< CentroidElement > getX() const
Return a Key for the x coordinate.
bool isValid
Definition: fits.cc:399
T isfinite(T... args)
afw::table::CatalogT< PeakRecord > PeakCatalog
Definition: Peak.h:244
int const NEGFLUXPAR(2)
int const NEGCENTXPAR(0)
int const NEGCENTYPAR(1)
int const POSFLUXPAR(5)
int const POSCENTXPAR(3)
int const POSCENTYPAR(4)
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174

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

◆ 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

◆ _flagHandler

meas::base::FlagHandler lsst::ip::diffim::DipoleFluxAlgorithm::_flagHandler
protectedinherited

Definition at line 145 of file DipoleAlgorithms.h.

◆ _fluxResultKey

meas::base::FluxResultKey lsst::ip::diffim::DipoleFluxAlgorithm::_fluxResultKey
protectedinherited

Definition at line 144 of file DipoleAlgorithms.h.

◆ _logName

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

Definition at line 69 of file Algorithm.h.

◆ _negativeKeys

ResultKey lsst::ip::diffim::DipoleFluxAlgorithm::_negativeKeys
protectedinherited

Definition at line 148 of file DipoleAlgorithms.h.

◆ _positiveKeys

ResultKey lsst::ip::diffim::DipoleFluxAlgorithm::_positiveKeys
protectedinherited

Definition at line 147 of file DipoleAlgorithms.h.

◆ FAILURE

meas::base::FlagDefinition const lsst::ip::diffim::DipoleFluxAlgorithm::FAILURE = dipoleFluxFlagDefinitions.addFailureFlag("general failure flag, set if anything went wrong")
staticinherited

Definition at line 118 of file DipoleAlgorithms.h.

◆ NEG_FLAG

meas::base::FlagDefinition const lsst::ip::diffim::DipoleFluxAlgorithm::NEG_FLAG = dipoleFluxFlagDefinitions.add("neg_flag", "failure flag for negative, set if anything went wrong")
staticinherited

Definition at line 120 of file DipoleAlgorithms.h.

◆ POS_FLAG

meas::base::FlagDefinition const lsst::ip::diffim::DipoleFluxAlgorithm::POS_FLAG = dipoleFluxFlagDefinitions.add("pos_flag", "failure flag for positive, set if anything went wrong")
staticinherited

Definition at line 119 of file DipoleAlgorithms.h.


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