lsst::afw::image::PhotoCalib Class Reference

The photometric calibration of an exposure. More...

#include <PhotoCalib.h>

Inheritance diagram for lsst::afw::image::PhotoCalib:

Public Member Functions
	PhotoCalib (PhotoCalib const &)=default
	PhotoCalib (PhotoCalib &&)=default
PhotoCalib &	operator= (PhotoCalib const &)=delete
PhotoCalib &	operator= (PhotoCalib &&)=delete
	~PhotoCalib () override=default
	PhotoCalib ()
	Create a empty, zeroed calibration.
	PhotoCalib (double calibrationMean, double calibrationErr=0, lsst::geom::Box2I const &bbox=lsst::geom::Box2I())
	Create a non-spatially-varying calibration.
	PhotoCalib (std::shared_ptr< afw::math::BoundedField > calibration, double calibrationErr=0)
	Create a spatially-varying calibration.
	PhotoCalib (double calibrationMean, double calibrationErr, std::shared_ptr< afw::math::BoundedField > calibration, bool isConstant)
	Create a calibration with a pre-computed mean.
double	instFluxToNanojansky (double instFlux, lsst::geom::Point< double, 2 > const &point) const
	Convert instFlux in ADU to nJy at a point in the BoundedField.
double	instFluxToNanojansky (double instFlux) const
Measurement	instFluxToNanojansky (double instFlux, double instFluxErr, lsst::geom::Point< double, 2 > const &point) const
	Convert instFlux and error in instFlux (ADU) to nJy and nJy error.
Measurement	instFluxToNanojansky (double instFlux, double instFluxErr) const
Measurement	instFluxToNanojansky (const afw::table::SourceRecord &sourceRecord, std::string const &instFluxField) const
	Convert sourceRecord[instFluxField_instFlux] (ADU) at location (sourceRecord.get("x"), sourceRecord.get("y")) (pixels) to flux and flux error (in nJy).
ndarray::Array< double, 2, 2 >	instFluxToNanojansky (afw::table::SourceCatalog const &sourceCatalog, std::string const &instFluxField) const
	Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to nJy.
void	instFluxToNanojansky (afw::table::SourceCatalog &sourceCatalog, std::string const &instFluxField, std::string const &outField) const
	Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to nJy and write the results back to sourceCatalog[outField_mag].
double	instFluxToMagnitude (double instFlux, lsst::geom::Point< double, 2 > const &point) const
	Convert instFlux in ADU to AB magnitude.
double	instFluxToMagnitude (double instFlux) const
Measurement	instFluxToMagnitude (double instFlux, double instFluxErr, lsst::geom::Point< double, 2 > const &point) const
	Convert instFlux and error in instFlux (ADU) to AB magnitude and magnitude error.
Measurement	instFluxToMagnitude (double instFlux, double instFluxErr) const
Measurement	instFluxToMagnitude (afw::table::SourceRecord const &sourceRecord, std::string const &instFluxField) const
	Convert sourceRecord[instFluxField_instFlux] (ADU) at location (sourceRecord.get("x"), sourceRecord.get("y")) (pixels) to AB magnitude.
ndarray::Array< double, 2, 2 >	instFluxToMagnitude (afw::table::SourceCatalog const &sourceCatalog, std::string const &instFluxField) const
	Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to AB magnitudes.
void	instFluxToMagnitude (afw::table::SourceCatalog &sourceCatalog, std::string const &instFluxField, std::string const &outField) const
	Convert instFluxes in a catalog to AB magnitudes and write back into the catalog.
MaskedImage< float >	calibrateImage (MaskedImage< float > const &maskedImage, bool includeScaleUncertainty=true) const
	Return a flux calibrated image, with pixel values in nJy.
MaskedImage< float >	uncalibrateImage (MaskedImage< float > const &maskedImage, bool includeScaleUncertainty=true) const
	Return a un-calibrated image, with pixel values in ADU (or whatever the original input to this photoCalib was).
afw::table::SourceCatalog	calibrateCatalog (afw::table::SourceCatalog const &catalog, std::vector< std::string > const &instFluxFields) const
	Return a flux calibrated catalog, with new _flux, _fluxErr, _mag, and _magErr fields.
afw::table::SourceCatalog	calibrateCatalog (afw::table::SourceCatalog const &catalog) const
double	magnitudeToInstFlux (double magnitude, lsst::geom::Point< double, 2 > const &point) const
	Convert AB magnitude to instFlux (ADU).
double	magnitudeToInstFlux (double magnitude) const
double	getCalibrationMean () const
	Get the mean photometric calibration.
double	getCalibrationErr () const
	Get the mean photometric calibration error.
bool	isConstant () const
	Is this photoCalib spatially constant?
double	getInstFluxAtZeroMagnitude () const
	Get the magnitude zero point (the instrumental flux corresponding to 0 magnitude).
double	getLocalCalibration (lsst::geom::Point< double, 2 > const &point) const
	Get the local calibration at a point.
std::shared_ptr< afw::math::BoundedField >	computeScaledCalibration () const
	Calculates the spatially-variable calibration, normalized by the mean in the valid domain.
std::shared_ptr< afw::math::BoundedField >	computeScalingTo (std::shared_ptr< PhotoCalib > other) const
	Calculates the scaling between this PhotoCalib and another PhotoCalib.
bool	operator== (PhotoCalib const &rhs) const
	Two PhotoCalibs are equal if their component bounded fields and calibrationErr are equal.
bool	operator!= (PhotoCalib const &rhs) const
	Two PhotoCalibs are equal if their component bounded fields and calibrationErr are equal.
bool	isPersistable () const noexcept override
	Return true if this particular object can be persisted using afw::table::io.
std::shared_ptr< typehandling::Storable >	cloneStorable () const override
	Create a new PhotoCalib that is a copy of this one.
std::string	toString () const override
	Create a string representation of this object.
bool	equals (typehandling::Storable const &other) const noexcept override
	Compare this object to another Storable.
virtual std::size_t	hash_value () const
	Return a hash of this object (optional operation).
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file.
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory.
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object.

Static Public Member Functions
static std::shared_ptr< PhotoCalib >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.
static std::shared_ptr< PhotoCalib >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.
static std::shared_ptr< PhotoCalib >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.
static std::shared_ptr< PhotoCalib >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

Protected Types
using	OutputArchiveHandle = io::OutputArchiveHandle

Protected Member Functions
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory.
void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs.
virtual std::string	getPythonModule () const
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Static Protected Member Functions
template<class T >
static bool	singleClassEquals (T const &lhs, Storable const &rhs)
	Test if a Storable is of a particular class and equal to another object.

Related Symbols
(Note that these are not member symbols.)
std::ostream &	operator<< (std::ostream &os, Storable const &storable)
	Output operator for Storable.

Detailed Description

The photometric calibration of an exposure.

A PhotoCalib is a BoundedField (a function with a specified domain) that converts from post-ISR counts-on-chip (ADU) to flux and magnitude. It is defined such that a calibration of 1 means one count is equal to one nanojansky (nJy, 10^-35 W/m^2/Hz in SI units). The nJy was chosen because it represents a linear flux unit with values in a convenient range (e.g. LSST's single image depth of 24.5 is 575 nJy). See more detailed discussion in: https://pstn-001.lsst.io/

PhotoCalib is immutable.

The spatially varying flux calibration has units of nJy/ADU, and is defined such that, at a position (x,y) in the domain of the boundedField calibration and for a given measured source instFlux:

\[ instFlux*calibration(x,y) = flux [nJy] \]

while the errors (constant on the domain) are defined as:

\[ sqrt((instFluxErr/instFlux)^2 + (calibrationErr/calibration)^2)*flux = fluxErr [nJy] \]

This implies that the conversions from instFlux and instFlux error to magnitude and magnitude error are as follows:

\[ -2.5*log_{10}(instFlux*calibration(x,y)*1e-9/referenceFlux) = magnitude \]

where referenceFlux is the AB Magnitude reference flux from Oke & Gunn 1983 (first equation),

\[ referenceFlux = 1e23 * 10^{(48.6/-2.5)} \]

and

\[ 2.5/log(10)*sqrt((instFluxErr/instFlux)^2 + (calibrationErr/calibration)^2) = magnitudeErr \]

Note that this is independent of referenceFlux.

Definition at line 114 of file PhotoCalib.h.

Member Typedef Documentation

OutputArchiveHandle

using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

Constructor & Destructor Documentation

PhotoCalib() [1/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( PhotoCalib const & )

default

PhotoCalib() [2/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( PhotoCalib && )

default

~PhotoCalib()

lsst::afw::image::PhotoCalib::~PhotoCalib ( )

overridedefault

PhotoCalib() [3/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( )

inline

Create a empty, zeroed calibration.

Definition at line 127 of file PhotoCalib.h.

: PhotoCalib(0) {}

PhotoCalib() [4/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( double calibrationMean, double calibrationErr = 0, lsst::geom::Box2I const & bbox = lsst::geom::Box2I() )

inlineexplicit

Create a non-spatially-varying calibration.

Parameters

[in]	calibrationMean	The spatially-constant calibration (must be non-negative).
[in]	calibrationErr	The error on the calibration (must be non-negative).
[in]	bbox	The bounding box on which this PhotoCalib is valid. If not specified, this PhotoCalib is valid at any point (i.e. an empty bbox).

Definition at line 137 of file PhotoCalib.h.

            : _calibrationMean(calibrationMean), _calibrationErr(calibrationErr), _isConstant(true) {
        assertNonNegative(_calibrationMean, "Calibration mean");
        assertNonNegative(_calibrationErr, "Calibration error");
        ndarray::Array<double, 2, 2> coeffs = ndarray::allocate(ndarray::makeVector(1, 1));
        coeffs[0][0] = calibrationMean;
        _calibration = std::make_shared<afw::math::ChebyshevBoundedField>(
                afw::math::ChebyshevBoundedField(bbox, coeffs));
    }

PhotoCalib() [5/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( std::shared_ptr< afw::math::BoundedField > calibration, double calibrationErr = 0 )

inline

Create a spatially-varying calibration.

Parameters

[in]	calibration	The spatially varying photometric calibration (must have non-negative mean).
[in]	calibrationErr	The error on the calibration (must be non-negative).

Definition at line 154 of file PhotoCalib.h.

            : _calibration(calibration),
              _calibrationMean(computeCalibrationMean(calibration)),
              _calibrationErr(calibrationErr),
              _isConstant(false) {
        assertNonNegative(_calibrationMean, "Calibration (computed via BoundedField.mean()) mean");
        assertNonNegative(_calibrationErr, "Calibration error");
    }

PhotoCalib() [6/6]

lsst::afw::image::PhotoCalib::PhotoCalib ( double calibrationMean, double calibrationErr, std::shared_ptr< afw::math::BoundedField > calibration, bool isConstant )

inline

Create a calibration with a pre-computed mean.

Primarily for de-persistence.

Parameters

[in]	calibrationMean	The mean of the calibration() over its bounding box (must be non-negative).
[in]	calibrationErr	The error on the calibration (must be non-negative).
[in]	calibration	The spatially varying photometric calibration.
[in]	isConstant	Is this PhotoCalib spatially constant?

Definition at line 171 of file PhotoCalib.h.

            : _calibration(calibration),
              _calibrationMean(calibrationMean),
              _calibrationErr(calibrationErr),
              _isConstant(isConstant) {
        assertNonNegative(_calibrationMean, "Calibration mean");
        assertNonNegative(_calibrationErr, "Calibration error");
    }

Member Function Documentation

calibrateCatalog() [1/2]

afw::table::SourceCatalog lsst::afw::image::PhotoCalib::calibrateCatalog

(

afw::table::SourceCatalog const &

catalog

)

const

Definition at line 399 of file PhotoCalib.cc.

                                                                                             {
    std::vector<std::string> instFluxFields;
    static std::string const SUFFIX = "_instFlux";
    for (auto const &name : catalog.getSchema().getNames()) {
        // Pick every field ending in "_instFlux", grabbing everything before that prefix.
        if (name.size() > SUFFIX.size() + 1 &&
            name.compare(name.size() - SUFFIX.size(), SUFFIX.size(), SUFFIX) == 0) {
            instFluxFields.emplace_back(name.substr(0, name.size() - 9));
        }
    }
    return calibrateCatalog(catalog, instFluxFields);
}

calibrateCatalog() [2/2]

afw::table::SourceCatalog lsst::afw::image::PhotoCalib::calibrateCatalog	(	afw::table::SourceCatalog const &	catalog,
		std::vector< std::string > const &	instFluxFields ) const

Return a flux calibrated catalog, with new _flux, _fluxErr, _mag, and _magErr fields.

If the input catalog already has _flux, _mag, _fluxErr, and/or _magErr fields matching instFluxFields, they will be replaced with the new fields.

Parameters

catalog	The source catalog to compute calibrated fluxes for.
instFluxFields	The fields to calibrate (optional). If not provided, every field ending with _instFlux will be calibrated.

Returns

A deep copy of the input catalog, with new calibrated flux and magnitude fields. Elements of instFluxFields that have _instFluxErr will be used to compute the _fluxErr and _magErr fields.

Exceptions

lsst::pex::exceptions::NotFoundError

if any item in instFluxFields does not have a corresponding *_instFlux field in catalog.schema.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 332 of file PhotoCalib.cc.

                                                                                                         {
    auto const &inSchema = catalog.getSchema();
    afw::table::SchemaMapper mapper(inSchema, true);  // true: share the alias map
    mapper.addMinimalSchema(inSchema);
 
    using FieldD = afw::table::Field<double>;
 
    struct Keys {
        table::Key<double> instFlux;
        table::Key<double> instFluxErr;
        table::Key<double> flux;
        table::Key<double> fluxErr;
        table::Key<double> mag;
        table::Key<double> magErr;
    };
 
    std::vector<Keys> keys;
    keys.reserve(instFluxFields.size());
    for (auto const &field : instFluxFields) {
        Keys newKey;
        newKey.instFlux = inSchema[inSchema.join(field, "instFlux")];
        newKey.flux =
                mapper.addOutputField(FieldD(inSchema.join(field, "flux"), "calibrated flux", "nJy"), true);
        newKey.mag = mapper.addOutputField(
                FieldD(inSchema.join(field, "mag"), "calibrated magnitude", "mag(AB)"), true);
        try {
            newKey.instFluxErr = inSchema.find<double>(inSchema.join(field, "instFluxErr")).key;
            newKey.fluxErr = mapper.addOutputField(
                    FieldD(inSchema.join(field, "fluxErr"), "calibrated flux uncertainty", "nJy"), true);
            newKey.magErr = mapper.addOutputField(
                    FieldD(inSchema.join(field, "magErr"), "calibrated magnitude uncertainty", "mag(AB)"),
                    true);
        } catch (pex::exceptions::NotFoundError &) {
            ;  // Keys struct defaults to invalid keys; that marks the error as missing.
        }
        keys.emplace_back(newKey);
    }
 
    // Create the new catalog
    afw::table::SourceCatalog output(mapper.getOutputSchema());
    output.insert(mapper, output.begin(), catalog.begin(), catalog.end());
 
    auto calibration = evaluateCatalog(output);
 
    // fill in the catalog values
    int iRec = 0;
    for (auto &rec : output) {
        for (auto &key : keys) {
            double instFlux = rec.get(key.instFlux);
            double nanojansky = toNanojansky(instFlux, calibration[iRec]);
            rec.set(key.flux, nanojansky);
            rec.set(key.mag, toMagnitude(instFlux, calibration[iRec]));
            if (key.instFluxErr.isValid()) {
                double instFluxErr = rec.get(key.instFluxErr);
                rec.set(key.fluxErr, toNanojanskyErr(instFlux, instFluxErr, calibration[iRec],
                                                     _calibrationErr, nanojansky));
                rec.set(key.magErr,
                        toMagnitudeErr(instFlux, instFluxErr, calibration[iRec], _calibrationErr));
            }
        }
        ++iRec;
    }
 
    return output;
}

calibrateImage()

MaskedImage< float > lsst::afw::image::PhotoCalib::calibrateImage	(	MaskedImage< float > const &	maskedImage,
		bool	includeScaleUncertainty = true ) const

Return a flux calibrated image, with pixel values in nJy.

Mask pixels are propagated directly from the input image.

Parameters

maskedImage	The masked image to calibrate.
includeScaleUncertainty	Include the uncertainty on the calibration in the resulting variance?

Returns

The calibrated masked image.

Definition at line 288 of file PhotoCalib.cc.

                                                                                  {
    // Deep copy construct, as we're mutiplying in-place.
    auto result = MaskedImage<float>(maskedImage, true);
 
    if (_isConstant) {
        *(result.getImage()) *= _calibrationMean;
    } else {
        _calibration->multiplyImage(*(result.getImage()), true);  // only in the overlap region
    }
    if (includeScaleUncertainty) {
        toNanojanskyVariance(maskedImage.getImage()->getArray(), maskedImage.getVariance()->getArray(),
                             _calibrationErr, result.getImage()->getArray(),
                             result.getVariance()->getArray());
    } else {
        toNanojanskyVariance(maskedImage.getImage()->getArray(), maskedImage.getVariance()->getArray(), 0,
                             result.getImage()->getArray(), result.getVariance()->getArray());
    }
 
    return result;
}

cloneStorable()

std::shared_ptr< typehandling::Storable > lsst::afw::image::PhotoCalib::cloneStorable ( ) const

overridevirtual

Create a new PhotoCalib that is a copy of this one.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 266 of file PhotoCalib.cc.

                                                                    {
    return std::make_unique<PhotoCalib>(*this);
}

computeScaledCalibration()

std::shared_ptr< math::BoundedField > lsst::afw::image::PhotoCalib::computeScaledCalibration

(

)

const

Calculates the spatially-variable calibration, normalized by the mean in the valid domain.

This value is defined, for instFlux at (x,y), such that:

\[ instFlux*computeScaledCalibration()(x,y)*getCalibrationMean() = instFluxToNanojansky(instFlux, (x,y)) \]

See also

PhotoCalib::getCalibrationMean()

Returns

The normalized spatially-variable calibration.

Definition at line 249 of file PhotoCalib.cc.

                                                                           {
    return *(_calibration) / _calibrationMean;
}

computeScalingTo()

std::shared_ptr< math::BoundedField > lsst::afw::image::PhotoCalib::computeScalingTo

(

std::shared_ptr< PhotoCalib >

other

)

const

Calculates the scaling between this PhotoCalib and another PhotoCalib.

The BoundedFields of these PhotoCalibs must have the same BBoxes (or one or both must be empty).

With:

• c = instFlux at position (x,y)
• this = this PhotoCalib
• other = other PhotoCalib
• return = BoundedField returned by this method the return value from this method is defined as:

  \[ this.instFluxToNanojansky(c, (x,y))*return(x, y) = other.instFluxToNanojansky(c, (x,y)) \]

Parameters

[in]

other

The PhotoCalib to scale to.

Returns

The BoundedField as defined above.

Warning

Not implemented yet: See DM-10154.

Definition at line 253 of file PhotoCalib.cc.

                                                                                                  {
    throw LSST_EXCEPT(pex::exceptions::LogicError, "Not Implemented: See DM-10154.");
}

dynamicCast()

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< PhotoCalib >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError

if the cast fails

param[in] ptr The pointer to be cast.

Returns

The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError

If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

equals()

bool lsst::afw::image::PhotoCalib::equals ( typehandling::Storable const & other ) const

overridevirtualnoexcept

Compare this object to another Storable.

Returns

*this == other if other is a PhotoCalib; otherwise false.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 280 of file PhotoCalib.cc.

                                                                        {
    return singleClassEquals(*this, other);
}

getCalibrationErr()

double lsst::afw::image::PhotoCalib::getCalibrationErr ( ) const

inline

Get the mean photometric calibration error.

This value is defined such that for some instFluxErr, instFlux, and flux:

\[ sqrt((instFluxErr/instFlux)^2 + (calibrationErr/calibration(x,y))^2)*flux = fluxErr [nJy] \]

See also

PhotoCalib::computeScaledCalibration(), getCalibrationMean()

Returns

The calibration error.

Definition at line 434 of file PhotoCalib.h.

{ return _calibrationErr; }

getCalibrationMean()

double lsst::afw::image::PhotoCalib::getCalibrationMean ( ) const

inline

Get the mean photometric calibration.

This value is defined, for instFlux at (x,y), such that:

\[ instFlux*computeScaledCalibration()(x,y)*getCalibrationMean() = instFluxToNanojansky(instFlux, (x,y)) \]

See also

PhotoCalib::computeScaledCalibration(), getCalibrationErr(), getInstFluxAtZeroMagnitude()

Returns

The spatial mean of this calibration.

Definition at line 420 of file PhotoCalib.h.

{ return _calibrationMean; }

getInstFluxAtZeroMagnitude()

double lsst::afw::image::PhotoCalib::getInstFluxAtZeroMagnitude ( ) const

inline

Get the magnitude zero point (the instrumental flux corresponding to 0 magnitude).

This value is defined such that:

\[ instFluxToMagnitude(getInstFluxAtZeroMagnitude()) == 0 \]

See also

PhotoCalib::computeScaledCalibration(), getCalibrationMean()

Returns

The instFlux magnitude zero point.

Definition at line 455 of file PhotoCalib.h.

{ return cpputils::referenceFlux / _calibrationMean; }

getLocalCalibration()

double lsst::afw::image::PhotoCalib::getLocalCalibration ( lsst::geom::Point< double, 2 > const & point ) const

inline

Get the local calibration at a point.

This value is defined such that:

\[ instFluxToNanojansky(instFlux, point) == localCalibration * inst \]

Use getCalibrationErr() to get the spatially constant error on the calibration.

Parameters

[in]

point

The position that magnitude is to be converted at.

See also

getCalibrationMean(), getCalibrationErr()

Returns

The local calibration at a point.

Definition at line 473 of file PhotoCalib.h.

{ return evaluate(point); }

getPersistenceName()

std::string lsst::afw::image::PhotoCalib::getPersistenceName ( ) const

overrideprotectedvirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 559 of file PhotoCalib.cc.

{ return getPhotoCalibPersistenceName(); }

getPythonModule()

std::string lsst::afw::table::io::Persistable::getPythonModule ( ) const

protectedvirtualinherited

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented in lsst::afw::image::FilterLabel, lsst::afw::cameraGeom::Detector, lsst::afw::cameraGeom::DetectorCollection, lsst::afw::cameraGeom::TransformMap, lsst::afw::detection::Footprint, lsst::afw::detection::GaussianPsf, lsst::afw::geom::SkyWcs, lsst::afw::geom::SpanSet, lsst::afw::geom::Transform< FromEndpoint, ToEndpoint >, lsst::afw::geom::Transform< afw::geom::Point2Endpoint, afw::geom::GenericEndpoint >, lsst::afw::image::ApCorrMap, lsst::afw::image::CoaddInputs, lsst::afw::image::TransmissionCurve, lsst::afw::math::ChebyshevBoundedField, lsst::afw::math::Function< double >, lsst::afw::math::Function< Kernel::Pixel >, lsst::afw::math::Function< Pixel >, lsst::afw::math::Function< ReturnT >, lsst::afw::math::Kernel, lsst::afw::math::PixelAreaBoundedField, lsst::afw::math::ProductBoundedField, lsst::afw::math::TransformBoundedField, lsst::afw::math::LanczosWarpingKernel, lsst::afw::math::BilinearWarpingKernel, lsst::afw::math::NearestWarpingKernel, lsst::afw::math::WarpingControl, lsst::afw::typehandling::StorableHelper< Base >, lsst::meas::algorithms::CoaddBoundedField, lsst::meas::algorithms::CoaddPsf, lsst::meas::algorithms::KernelPsf, lsst::meas::algorithms::WarpedPsf, lsst::meas::extensions::psfex::PsfexPsf, and lsst::meas::modelfit::Mixture.

Definition at line 36 of file Persistable.cc.

{ return std::string(); }

hash_value()

std::size_t lsst::afw::typehandling::Storable::hash_value ( ) const

virtualinherited

Return a hash of this object (optional operation).

Exceptions

UnsupportedOperationException

Thrown if this object is not hashable.

Note

C++ subclass authors are responsible for any associated specializations of std::hash.

When called on Python classes, this method delegates to __hash__ if it exists.

Reimplemented in lsst::afw::geom::polygon::Polygon, lsst::afw::image::FilterLabel, lsst::afw::image::VisitInfo, and lsst::afw::typehandling::StorableHelper< Base >.

Definition at line 44 of file Storable.cc.

                                     {
    throw LSST_EXCEPT(UnsupportedOperationException, "Hashes are not supported.");
}

instFluxToMagnitude() [1/7]

void lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	afw::table::SourceCatalog &	sourceCatalog,
		std::string const &	instFluxField,
		std::string const &	outField ) const

Convert instFluxes in a catalog to AB magnitudes and write back into the catalog.

Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to AB magnitudes and write the results back to sourceCatalog[outField_mag].

Parameters

[in]	sourceCatalog	The source catalog to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"
[in]	outField	The field to write the magnitudes and magnitude errors to. Keys of the form "*_instFlux", "*_instFluxErr", *_mag", and "*_magErr" must exist in the schema.

Definition at line 225 of file PhotoCalib.cc.

                                                                                                      {
    auto instFluxKey = sourceCatalog.getSchema().find<double>(instFluxField + "_instFlux").key;
    auto instFluxErrKey = sourceCatalog.getSchema().find<double>(instFluxField + "_instFluxErr").key;
    auto magKey = sourceCatalog.getSchema().find<double>(outField + "_mag").key;
    auto magErrKey = sourceCatalog.getSchema().find<double>(outField + "_magErr").key;
    for (auto &record : sourceCatalog) {
        auto result = instFluxToMagnitude(record.get(instFluxKey), record.get(instFluxErrKey),
                                          record.getCentroid());
        record.set(magKey, result.value);
        record.set(magErrKey, result.error);
    }
}

instFluxToMagnitude() [2/7]

ndarray::Array< double, 2, 2 > lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	afw::table::SourceCatalog const &	sourceCatalog,
		std::string const &	instFluxField ) const

Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to AB magnitudes.

Parameters

[in]	sourceCatalog	The source catalog to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"

Returns

The magnitudes and magnitude errors for the sources.

Definition at line 217 of file PhotoCalib.cc.

                                                                                                   {
    ndarray::Array<double, 2, 2> result =
            ndarray::allocate(ndarray::makeVector(int(sourceCatalog.size()), 2));
    instFluxToMagnitudeArray(sourceCatalog, instFluxField, result);
    return result;
}

instFluxToMagnitude() [3/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	afw::table::SourceRecord const &	sourceRecord,
		std::string const &	instFluxField ) const

Convert sourceRecord[instFluxField_instFlux] (ADU) at location (sourceRecord.get("x"), sourceRecord.get("y")) (pixels) to AB magnitude.

Parameters

[in]	sourceRecord	The source record to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"

Returns

The magnitude and magnitude error for this source.

Definition at line 209 of file PhotoCalib.cc.

                                                                                  {
    auto position = sourceRecord.getCentroid();
    auto instFluxKey = sourceRecord.getSchema().find<double>(instFluxField + "_instFlux").key;
    auto instFluxErrKey = sourceRecord.getSchema().find<double>(instFluxField + "_instFluxErr").key;
    return instFluxToMagnitude(sourceRecord.get(instFluxKey), sourceRecord.get(instFluxErrKey), position);
}

instFluxToMagnitude() [4/7]

double lsst::afw::image::PhotoCalib::instFluxToMagnitude

(

double

instFlux

)

const

Definition at line 190 of file PhotoCalib.cc.

                                                            {
    return toMagnitude(instFlux, _calibrationMean);
}

instFluxToMagnitude() [5/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	double	instFlux,
		double	instFluxErr ) const

Definition at line 203 of file PhotoCalib.cc.

                                                                                     {
    double magnitude = toMagnitude(instFlux, _calibrationMean);
    double error = toMagnitudeErr(instFlux, instFluxErr, _calibrationMean, _calibrationErr);
    return Measurement(magnitude, error);
}

instFluxToMagnitude() [6/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	double	instFlux,
		double	instFluxErr,
		lsst::geom::Point< double, 2 > const &	point ) const

Convert instFlux and error in instFlux (ADU) to AB magnitude and magnitude error.

If passed point, use the exact calculation at that point, otherwise, use the mean scaling factor.

Parameters

[in]	instFlux	The source instFlux in ADU.
[in]	instFluxErr	The instFlux error (standard deviation).
[in]	point	The point that instFlux is measured at.

Returns

The AB magnitude and error.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 194 of file PhotoCalib.cc.

                                                                                         {
    double calibration, error, magnitude;
    calibration = evaluate(point);
    magnitude = toMagnitude(instFlux, calibration);
    error = toMagnitudeErr(instFlux, instFluxErr, calibration, _calibrationErr);
    return Measurement(magnitude, error);
}

instFluxToMagnitude() [7/7]

double lsst::afw::image::PhotoCalib::instFluxToMagnitude	(	double	instFlux,
		lsst::geom::Point< double, 2 > const &	point ) const

Convert instFlux in ADU to AB magnitude.

If passed point, use the exact calculation at that point, otherwise, use the mean scaling factor.

Parameters

[in]	instFlux	The source instFlux in ADU.
[in]	point	The point that instFlux is measured at.

Returns

The AB magnitude.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 186 of file PhotoCalib.cc.

                                                                                                   {
    return toMagnitude(instFlux, evaluate(point));
}

instFluxToNanojansky() [1/7]

void lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	afw::table::SourceCatalog &	sourceCatalog,
		std::string const &	instFluxField,
		std::string const &	outField ) const

Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to nJy and write the results back to sourceCatalog[outField_mag].

Parameters

[in]	sourceCatalog	The source catalog to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"
[in]	outField	The field to write the nJy and magnitude errors to. Keys of the form "*_instFlux" and "*_instFluxErr" must exist in the schema.

Definition at line 170 of file PhotoCalib.cc.

                                                                                                       {
    auto instFluxKey = sourceCatalog.getSchema().find<double>(instFluxField + "_instFlux").key;
    auto instFluxErrKey = sourceCatalog.getSchema().find<double>(instFluxField + "_instFluxErr").key;
    auto nanojanskyKey = sourceCatalog.getSchema().find<double>(outField + "_flux").key;
    auto nanojanskyErrKey = sourceCatalog.getSchema().find<double>(outField + "_fluxErr").key;
    for (auto &record : sourceCatalog) {
        auto result = instFluxToNanojansky(record.get(instFluxKey), record.get(instFluxErrKey),
                                           record.getCentroid());
        record.set(nanojanskyKey, result.value);
        record.set(nanojanskyErrKey, result.error);
    }
}

instFluxToNanojansky() [2/7]

ndarray::Array< double, 2, 2 > lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	afw::table::SourceCatalog const &	sourceCatalog,
		std::string const &	instFluxField ) const

Convert sourceCatalog[instFluxField_instFlux] (ADU) at locations (sourceCatalog.get("x"), sourceCatalog.get("y")) (pixels) to nJy.

Parameters

[in]	sourceCatalog	The source catalog to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"

Returns

The flux in nJy and error for this source.

Definition at line 162 of file PhotoCalib.cc.

                                                                                                    {
    ndarray::Array<double, 2, 2> result =
            ndarray::allocate(ndarray::makeVector(int(sourceCatalog.size()), 2));
    instFluxToNanojanskyArray(sourceCatalog, instFluxField, result);
    return result;
}

instFluxToNanojansky() [3/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	const afw::table::SourceRecord &	sourceRecord,
		std::string const &	instFluxField ) const

Convert sourceRecord[instFluxField_instFlux] (ADU) at location (sourceRecord.get("x"), sourceRecord.get("y")) (pixels) to flux and flux error (in nJy).

Parameters

[in]	sourceRecord	The source record to get instFlux and position from.
[in]	instFluxField	The instFlux field: Keys of the form "*_instFlux" and "*_instFluxErr" must exist. For example: instFluxField="slot_PsfFlux" will use the fields named: "slot_PsfFlux_instFlux", "slot_PsfFlux_instFluxErr"

Returns

The flux in nJy and error for this source.

Definition at line 155 of file PhotoCalib.cc.

                                                                                   {
    auto position = sourceRecord.getCentroid();
    auto instFluxKey = sourceRecord.getSchema().find<double>(instFluxField + "_instFlux").key;
    auto instFluxErrKey = sourceRecord.getSchema().find<double>(instFluxField + "_instFluxErr").key;
    return instFluxToNanojansky(sourceRecord.get(instFluxKey), sourceRecord.get(instFluxErrKey), position);
}

instFluxToNanojansky() [4/7]

double lsst::afw::image::PhotoCalib::instFluxToNanojansky

(

double

instFlux

)

const

Definition at line 136 of file PhotoCalib.cc.

                                                             {
    return toNanojansky(instFlux, _calibrationMean);
}

instFluxToNanojansky() [5/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	double	instFlux,
		double	instFluxErr ) const

Definition at line 149 of file PhotoCalib.cc.

                                                                                      {
    double nanojansky = toNanojansky(instFlux, _calibrationMean);
    double error = toNanojanskyErr(instFlux, instFluxErr, _calibrationMean, _calibrationErr, nanojansky);
    return Measurement(nanojansky, error);
}

instFluxToNanojansky() [6/7]

Measurement lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	double	instFlux,
		double	instFluxErr,
		lsst::geom::Point< double, 2 > const &	point ) const

Convert instFlux and error in instFlux (ADU) to nJy and nJy error.

If passed point, use the exact calculation at that point, otherwise, use the mean scaling factor.

Parameters

[in]	instFlux	The source fluxinstFlux in ADU.
[in]	instFluxErr	The instFlux error.
[in]	point	The point that instFlux is measured at.

Returns

The flux in nJy and error.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 140 of file PhotoCalib.cc.

                                                                                          {
    double calibration, error, nanojansky;
    calibration = evaluate(point);
    nanojansky = toNanojansky(instFlux, calibration);
    error = toNanojanskyErr(instFlux, instFluxErr, calibration, _calibrationErr, nanojansky);
    return Measurement(nanojansky, error);
}

instFluxToNanojansky() [7/7]

double lsst::afw::image::PhotoCalib::instFluxToNanojansky	(	double	instFlux,
		lsst::geom::Point< double, 2 > const &	point ) const

Convert instFlux in ADU to nJy at a point in the BoundedField.

If passed point, use the exact calculation at that point, otherwise, use the mean scaling factor.

Parameters

[in]	instFlux	The source instFlux in ADU.
[in]	point	The point that instFlux is measured at.

Returns

The flux in nJy.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 132 of file PhotoCalib.cc.

                                                                                                    {
    return toNanojansky(instFlux, evaluate(point));
}

isConstant()

bool lsst::afw::image::PhotoCalib::isConstant ( ) const

inline

Is this photoCalib spatially constant?

Returns

Is the calibration spatially constant?

Definition at line 441 of file PhotoCalib.h.

{ return _isConstant; }

isPersistable()

bool lsst::afw::image::PhotoCalib::isPersistable ( ) const

inlineoverridevirtualnoexcept

Return true if this particular object can be persisted using afw::table::io.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 519 of file PhotoCalib.h.

{ return true; }

magnitudeToInstFlux() [1/2]

double lsst::afw::image::PhotoCalib::magnitudeToInstFlux

(

double

magnitude

)

const

Definition at line 241 of file PhotoCalib.cc.

                                                             {
    return toInstFluxFromMagnitude(magnitude, _calibrationMean);
}

magnitudeToInstFlux() [2/2]

double lsst::afw::image::PhotoCalib::magnitudeToInstFlux	(	double	magnitude,
		lsst::geom::Point< double, 2 > const &	point ) const

Convert AB magnitude to instFlux (ADU).

If passed point, use the exact calculation at that point, otherwise, use the mean scaling factor.

Useful for inserting fake sources into an image.

Parameters

[in]	magnitude	The AB magnitude to convert.
[in]	point	The position that magnitude is to be converted at.

Returns

Source instFlux in ADU.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 245 of file PhotoCalib.cc.

                                                                                                    {
    return toInstFluxFromMagnitude(magnitude, evaluate(point));
}

operator!=()

bool lsst::afw::image::PhotoCalib::operator!= ( PhotoCalib const & rhs ) const

inline

Two PhotoCalibs are equal if their component bounded fields and calibrationErr are equal.

Definition at line 517 of file PhotoCalib.h.

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

operator=() [1/2]

PhotoCalib & lsst::afw::image::PhotoCalib::operator= ( PhotoCalib && )

delete

operator=() [2/2]

PhotoCalib & lsst::afw::image::PhotoCalib::operator= ( PhotoCalib const & )

delete

operator==()

bool lsst::afw::image::PhotoCalib::operator==

(

PhotoCalib const &

rhs

)

const

Two PhotoCalibs are equal if their component bounded fields and calibrationErr are equal.

Definition at line 257 of file PhotoCalib.cc.

                                                       {
    return (_calibrationMean == rhs._calibrationMean && _calibrationErr == rhs._calibrationErr &&
            (*_calibration) == *(rhs._calibration));
}

readFits() [1/3]

static std::shared_ptr< PhotoCalib > lsst::afw::table::io::PersistableFacade< PhotoCalib >::readFits ( fits::Fits & fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in]

fitsfile

FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

readFits() [2/3]

static std::shared_ptr< PhotoCalib > lsst::afw::table::io::PersistableFacade< PhotoCalib >::readFits ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

readFits() [3/3]

static std::shared_ptr< PhotoCalib > lsst::afw::table::io::PersistableFacade< PhotoCalib >::readFits ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

singleClassEquals()

template<class T >

static bool lsst::afw::typehandling::Storable::singleClassEquals ( T const & lhs, Storable const & rhs )

inlinestaticprotectedinherited

Test if a Storable is of a particular class and equal to another object.

This method template simplifies implementations of equals that delegate to operator== without supporting cross-class comparisons.

Template Parameters

T	The class expected of the two objects to be compared.

Parameters

lhs,rhs

The objects to compare. Note that rhs need not be a T, while lhs must be.

Returns

true if rhs is a T and lhs == rhs; false otherwise.

Exception Safety

Provides the same level of exception safety as operator==. Most implementations of operator== do not throw.

Note

This method template calls operator== with both arguments of compile-time type T const&. Its use is not recommended if there would be any ambiguity as to which operator== gets picked by overload resolution.

This method template is typically called from equals as:

bool MyType::equals(Storable const& other) const noexcept {
    return singleClassEquals(*this, other);
}

Definition at line 151 of file Storable.h.

                                                                     {
        auto typedRhs = dynamic_cast<T const*>(&rhs);
        if (typedRhs != nullptr) {
            return lhs == *typedRhs;
        } else {
            return false;
        }
    }

toString()

std::string lsst::afw::image::PhotoCalib::toString ( ) const

overridevirtual

Create a string representation of this object.

Reimplemented from lsst::afw::typehandling::Storable.

Definition at line 270 of file PhotoCalib.cc.

                                     {
    std::stringstream buffer;
    if (_isConstant)
        buffer << "spatially constant with ";
    else
        buffer << *_calibration << " with ";
    buffer << "mean: " << _calibrationMean << " error: " << _calibrationErr;
    return buffer.str();
}

uncalibrateImage()

MaskedImage< float > lsst::afw::image::PhotoCalib::uncalibrateImage	(	MaskedImage< float > const &	maskedImage,
		bool	includeScaleUncertainty = true ) const

Return a un-calibrated image, with pixel values in ADU (or whatever the original input to this photoCalib was).

Mask pixels are propagated directly from the input image.

Parameters

maskedImage	The masked image with pixel units of nJy to uncalibrate.
includeScaleUncertainty	Remove uncertainty from this calibration that was previously propagated into the variance plane. Must have the same value as the parameter of the same name when calibrateImage was called on this image.

Returns

The uncalibrated masked image.

Definition at line 310 of file PhotoCalib.cc.

                                                                                    {
    // Deep copy construct, as we're mutiplying in-place.
    auto result = MaskedImage<float>(maskedImage, true);
 
    if (_isConstant) {
        *(result.getImage()) /= _calibrationMean;
    } else {
        _calibration->divideImage(*(result.getImage()), true);  // only in the overlap region
    }
    if (includeScaleUncertainty) {
        fromNanojanskyVariance(maskedImage.getImage()->getArray(), maskedImage.getVariance()->getArray(),
                               _calibrationErr, result.getImage()->getArray(),
                               result.getVariance()->getArray());
    } else {
        fromNanojanskyVariance(maskedImage.getImage()->getArray(), maskedImage.getVariance()->getArray(), 0,
                               result.getImage()->getArray(), result.getVariance()->getArray());
    }
 
    return result;
}

write()

void lsst::afw::image::PhotoCalib::write ( OutputArchiveHandle & handle ) const

overrideprotectedvirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 561 of file PhotoCalib.cc.

                                                        {
    PhotoCalibSchema const &keys = PhotoCalibSchema::get();
    table::BaseCatalog catalog = handle.makeCatalog(keys.schema);
    auto record = catalog.addNew();
    record->set(keys.calibrationMean, _calibrationMean);
    record->set(keys.calibrationErr, _calibrationErr);
    record->set(keys.isConstant, _isConstant);
    record->set(keys.field, handle.put(_calibration));
    record->set(keys.version, SERIALIZATION_VERSION);
    handle.saveCatalog(catalog);
}

writeFits() [1/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::Fits & fitsfile ) const

inherited

Write the object to an already-open FITS object.

Parameters

[in]

fitsfile

Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

                                                    {
    OutputArchive archive;
    archive.put(this);
    archive.writeFits(fitsfile);
}

writeFits() [2/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::MemFileManager & manager, std::string const & mode = "w" ) const

inherited

Write the object to a FITS image in memory.

Parameters

[in]	manager	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

                                                                                    {
    fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

writeFits() [3/3]

void lsst::afw::table::io::Persistable::writeFits ( std::string const & fileName, std::string const & mode = "w" ) const

inherited

Write the object to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

                                                                                  {
    fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

Friends And Related Symbol Documentation

operator<<()

std::ostream & operator<< ( std::ostream & os, Storable const & storable )

related

Output operator for Storable.

Parameters

os	the desired output stream
storable	the object to print

Returns

a reference to os

Exceptions

UnsupportedOperationException

Thrown if storable does not have an implementation of Storable::toString.

Definition at line 174 of file Storable.h.

                                                                        {
    return os << storable.toString();
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+10f999ec6a/include/lsst/afw/image/PhotoCalib.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/afw/g9726552aa6+10f999ec6a/src/image/PhotoCalib.cc