lsst.afw.image::Calib Class Reference

#include <Calib.h>

Inheritance diagram for lsst.afw.image::Calib:

Public Types
typedef boost::shared_ptr< Calib >	Ptr
typedef boost::shared_ptr < Calib const >	ConstPtr

Public Member Functions
	Calib ()
	Calib (std::vector< boost::shared_ptr< Calib const >> const &calibs)
	Calib (boost::shared_ptr< lsst::daf::base::PropertySet const >)
void	setMidTime (lsst::daf::base::DateTime const &midTime)
lsst::daf::base::DateTime	getMidTime () const
lsst::daf::base::DateTime	getMidTime (boost::shared_ptr< const lsst::afw::cameraGeom::Detector >, lsst::afw::geom::Point2I const &) const
void	setExptime (double exptime)
double	getExptime () const
void	setFluxMag0 (double fluxMag0, double fluxMag0Sigma=0.0)
void	setFluxMag0 (std::pair< double, double > fluxMag0AndSigma)
std::pair< double, double >	getFluxMag0 () const
double	getFlux (double const mag) const
std::pair< double, double >	getFlux (double const mag, double const magErr) const
ndarray::Array< double, 1 >	getFlux (ndarray::Array< double const, 1 > const &mag) const
std::pair< ndarray::Array < double, 1 >, ndarray::Array < double, 1 > >	getFlux (ndarray::Array< double const, 1 > const &mag, ndarray::Array< double const, 1 > const &magErr) const
double	getMagnitude (double const flux) const
std::pair< double, double >	getMagnitude (double const flux, double const fluxErr) const
ndarray::Array< double, 1 >	getMagnitude (ndarray::Array< double const, 1 > const &flux) const
std::pair< ndarray::Array < double, 1 >, ndarray::Array < double, 1 > >	getMagnitude (ndarray::Array< double const, 1 > const &flux, ndarray::Array< double const, 1 > const &fluxErr) const
bool	operator== (Calib const &rhs) const
bool	operator!= (Calib const &rhs) const
bool	isPersistable () const
	Return true if this particular object can be persisted using afw::table::io. More...
Public Member Functions inherited from lsst.afw.table.io::Persistable
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file. More...
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory. More...
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object. More...
virtual	~Persistable ()

Static Public Member Functions
static void	setThrowOnNegativeFlux (bool raiseException)
static bool	getThrowOnNegativeFlux ()
Static Public Member Functions inherited from lsst.afw.table.io::PersistableFacade< Calib >
static boost::shared_ptr< Calib >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...
static boost::shared_ptr< Calib >	readFits (std::string const &fileName, int hdu=0)
	Read an object from a regular FITS file. More...
static boost::shared_ptr< Calib >	readFits (fits::MemFileManager &manager, int hdu=0)
	Read an object from a FITS file in memory. More...

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

Private Attributes
lsst::daf::base::DateTime	_midTime
double	_exptime
double	_fluxMag0
double	_fluxMag0Sigma

Static Private Attributes
static bool	_throwOnNegativeFlux = true

Additional Inherited Members
Protected Types inherited from lsst.afw.table.io::Persistable
typedef io::OutputArchiveHandle	OutputArchiveHandle

Detailed Description

Describe an exposure's calibration

Definition at line 82 of file Calib.h.

Member Typedef Documentation

typedef boost::shared_ptr<Calib const> lsst.afw.image::Calib::ConstPtr

Definition at line 85 of file Calib.h.

typedef boost::shared_ptr<Calib> lsst.afw.image::Calib::Ptr

Definition at line 84 of file Calib.h.

Constructor & Destructor Documentation

lsst.afw.image::Calib::Calib ( )

explicit

ctor

Definition at line 49 of file Calib.cc.

: _midTime(), _exptime(0.0), _fluxMag0(0.0), _fluxMag0Sigma(0.0) {}

lsst.afw.image::Calib::Calib ( std::vector< boost::shared_ptr< Calib const >> const &  calibs )

explicit

ctor from a vector of Calibs

Note

All the input calibs must have the same zeropoint; throw InvalidParameterError if this isn't true

Parameters

calibs

Set of calibs to be merged

Definition at line 55 of file Calib.cc.

              :
    _midTime(), _exptime(0.0), _fluxMag0(0.0), _fluxMag0Sigma(0.0)
{
    if (calibs.empty()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                          "You must provide at least one input Calib");
    }

    double const fluxMag00 = calibs[0]->_fluxMag0;
    double const fluxMag0Sigma0 = calibs[0]->_fluxMag0Sigma;

    double midTimeSum = 0.0;            // sum(time*expTime)
    for (std::vector<CONST_PTR(Calib)>::const_iterator ptr = calibs.begin(); ptr != calibs.end(); ++ptr) {
        Calib const& calib = **ptr;

        if (::fabs(fluxMag00 - calib._fluxMag0) > std::numeric_limits<double>::epsilon() ||
            ::fabs(fluxMag0Sigma0 - calib._fluxMag0Sigma) > std::numeric_limits<double>::epsilon()) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              (boost::format("You may only combine calibs with the same fluxMag0: "
                                             "%g +- %g v %g +- %g")
                               % calib.getFluxMag0().first % calib.getFluxMag0().second
                               % calibs[0]->getFluxMag0().first % calibs[0]->getFluxMag0().second
                              ).str());
        }

        double const exptime = calib._exptime;

        midTimeSum += calib._midTime.get()*exptime;
        _exptime += exptime;
    }

    daf::base::DateTime tmp(midTimeSum/_exptime); // there's no way to set the double value directly
    using std::swap;
    swap(_midTime, tmp);
}

lsst.afw.image::Calib::Calib ( boost::shared_ptr< lsst::daf::base::PropertySet const >  metadata )

explicit

ctor

Definition at line 95 of file Calib.cc.

                                                       {
    lsst::daf::base::DateTime midTime;
    double exptime = 0.0;
    double fluxMag0 = 0.0, fluxMag0Sigma = 0.0;

    std::string key = "TIME-MID";
    if (metadata->exists(key)) {
        midTime  = lsst::daf::base::DateTime(boost::algorithm::trim_right_copy(metadata->getAsString(key)));
    }

    key = "EXPTIME";
    if (metadata->exists(key)) {
        try {
            exptime = metadata->getAsDouble(key);
        } catch (lsst::pex::exceptions::TypeError & err) {
            std::string exptimeStr = metadata->getAsString(key);
            exptime = boost::lexical_cast<double>(exptimeStr);
        }
    }

    key = "FLUXMAG0";
    if (metadata->exists(key)) {
        fluxMag0 = metadata->getAsDouble(key);
        
        key = "FLUXMAG0ERR";
        if (metadata->exists(key)) {
            fluxMag0Sigma = metadata->getAsDouble(key);
        }
    }
        
    _midTime = midTime;
    _exptime = exptime;
    _fluxMag0 = fluxMag0;
    _fluxMag0Sigma = fluxMag0Sigma;
}

Member Function Documentation

double lsst.afw.image::Calib::getExptime

(

)

const

Return the length of an exposure in seconds

Definition at line 249 of file Calib.cc.

{
    return _exptime;
}

double lsst.afw.image::Calib::getFlux

(

double const

mag

)

const

Return a flux (in ADUs) given a magnitude

Parameters

mag	the magnitude of the object

Definition at line 329 of file Calib.cc.

                                {
    checkNegativeFlux0(_fluxMag0);
    return convertToFlux(_fluxMag0, mag);
}

std::pair< double, double > lsst.afw.image::Calib::getFlux	(	double const	mag,
		double const	magSigma
	)		const

Return a flux and flux error (in ADUs) given a magnitude and magnitude error

Assumes that the errors are small and uncorrelated.

Parameters

mag	the magnitude of the object
magSigma	the error in the magnitude

Definition at line 350 of file Calib.cc.

{
    checkNegativeFlux0(_fluxMag0);
    double const flux = convertToFlux(_fluxMag0, mag);
    double const fluxErr = convertToFluxErr(_fluxMag0Sigma/_fluxMag0, flux, magSigma);
    return std::make_pair(flux, fluxErr);
}

ndarray::Array< double, 1 > lsst.afw.image::Calib::getFlux

(

ndarray::Array< double const, 1 > const &

mag

)

const

Definition at line 334 of file Calib.cc.

                                                                                    {
    checkNegativeFlux0(_fluxMag0);
    ndarray::Array<double,1> flux = ndarray::allocate(mag.size());
    ndarray::Array<double const,1>::Iterator inIter = mag.begin();
    ndarray::Array<double,1>::Iterator outIter = flux.begin();
    for (; inIter != mag.end(); ++inIter, ++outIter) {
        *outIter = convertToFlux(_fluxMag0, *inIter);
    }
    return flux;
}

std::pair< ndarray::Array< double, 1 >, ndarray::Array< double, 1 > > lsst.afw.image::Calib::getFlux	(	ndarray::Array< double const, 1 > const &	mag,
		ndarray::Array< double const, 1 > const &	magErr
	)		const

Definition at line 361 of file Calib.cc.

        {
    checkNegativeFlux0(_fluxMag0);
    if (mag.size() != magErr.size()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Size of mag (%d) and magErr (%d) don't match") % 
                           mag.size() % magErr.size()).str());
    }

    ndarray::Array<double,1> flux = ndarray::allocate(mag.size());
    ndarray::Array<double,1> fluxErr = ndarray::allocate(mag.size());
    ndarray::Array<double const,1>::Iterator magIter = mag.begin();
    ndarray::Array<double const,1>::Iterator magErrIter = magErr.begin();
    ndarray::Array<double,1>::Iterator fluxIter = flux.begin();
    ndarray::Array<double,1>::Iterator fluxErrIter = fluxErr.begin();

    double fluxMag0InvSNR = _fluxMag0Sigma/_fluxMag0;
    for (; magIter != mag.end(); ++magIter, ++magErrIter, ++fluxIter, ++fluxErrIter) {
        *fluxIter = convertToFlux(_fluxMag0, *magIter);
        *fluxErrIter = convertToFluxErr(fluxMag0InvSNR, *fluxIter, *magErrIter);
    }

    return std::make_pair(flux, fluxErr);
}

std::pair< double, double > lsst.afw.image::Calib::getFluxMag0

(

)

const

Return the flux, and error in flux, of a zero-magnitude object

Definition at line 274 of file Calib.cc.

{
    return std::make_pair(_fluxMag0, _fluxMag0Sigma);
}

double lsst.afw.image::Calib::getMagnitude

(

double const

flux

)

const

Return a magnitude given a flux

Parameters

flux	the measured flux of the object (ADUs)

Definition at line 391 of file Calib.cc.

{
    checkNegativeFlux0(_fluxMag0);
    if (isNegativeFlux(flux, Calib::getThrowOnNegativeFlux())) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    return convertToMag(_fluxMag0, flux);
}

std::pair< double, double > lsst.afw.image::Calib::getMagnitude	(	double const	flux,
		double const	fluxErr
	)		const

Return a magnitude and magnitude error given a flux and flux error

Parameters

flux	the measured flux of the object (ADUs)
fluxErr	the error in the measured flux (ADUs)

Definition at line 404 of file Calib.cc.

{
    checkNegativeFlux0(_fluxMag0);
    if (isNegativeFlux(flux, Calib::getThrowOnNegativeFlux())) {
        double const NaN = std::numeric_limits<double>::quiet_NaN();
        return std::make_pair(NaN, NaN);
    }

    double mag, magErr;
    convertToMagWithErr(&mag, &magErr, _fluxMag0, _fluxMag0Sigma/_fluxMag0, flux, fluxErr);
    return std::make_pair(mag, magErr);
}

ndarray::Array< double, 1 > lsst.afw.image::Calib::getMagnitude

(

ndarray::Array< double const, 1 > const &

flux

)

const

Definition at line 419 of file Calib.cc.

                                                                                          {
    checkNegativeFlux0(_fluxMag0);
    ndarray::Array<double,1> mag = ndarray::allocate(flux.size());
    ndarray::Array<double const,1>::Iterator fluxIter = flux.begin();
    ndarray::Array<double,1>::Iterator magIter = mag.begin();
    int nonPositive = 0;
    for (; fluxIter != flux.end(); ++fluxIter, ++magIter) {
        if (isNegativeFlux(*fluxIter, false)) {
            ++nonPositive;
            *magIter = std::numeric_limits<double>::quiet_NaN();
            continue;
        }
        *magIter = convertToMag(_fluxMag0, *fluxIter);
    }
    if (nonPositive && Calib::getThrowOnNegativeFlux()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::DomainError,
                          (boost::format("Flux must be >= 0: %d non-positive seen") % nonPositive).str());
    }
    return mag;
}

std::pair< ndarray::Array< double, 1 >, ndarray::Array< double, 1 > > lsst.afw.image::Calib::getMagnitude	(	ndarray::Array< double const, 1 > const &	flux,
		ndarray::Array< double const, 1 > const &	fluxErr
	)		const

Definition at line 440 of file Calib.cc.

        {
    checkNegativeFlux0(_fluxMag0);
    if (flux.size() != fluxErr.size()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Size of flux (%d) and fluxErr (%d) don't match") % 
                           flux.size() % fluxErr.size()).str());
    }

    ndarray::Array<double,1> mag = ndarray::allocate(flux.size());
    ndarray::Array<double,1> magErr = ndarray::allocate(flux.size());
    ndarray::Array<double const,1>::Iterator fluxIter = flux.begin();
    ndarray::Array<double const,1>::Iterator fluxErrIter = fluxErr.begin();
    ndarray::Array<double,1>::Iterator magIter = mag.begin();
    ndarray::Array<double,1>::Iterator magErrIter = magErr.begin();
    int nonPositive = 0;
    double fluxMag0InvSNR = _fluxMag0Sigma/_fluxMag0;
    for (; fluxIter != flux.end(); ++fluxIter, ++fluxErrIter, ++magIter, ++magErrIter) {
        if (isNegativeFlux(*fluxIter, false)) {
            ++nonPositive;
            double const NaN = std::numeric_limits<double>::quiet_NaN();
            *magIter = NaN;
            *magErrIter = NaN;
            continue;
        }
        double f, df;
        convertToMagWithErr(&f, &df, _fluxMag0, fluxMag0InvSNR, *fluxIter, *fluxErrIter);
        *magIter = f;
        *magErrIter = df;
    }
    if (nonPositive && Calib::getThrowOnNegativeFlux()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::DomainError,
                          (boost::format("Flux must be >= 0: %d non-positive seen") % nonPositive).str());
    }
    return std::make_pair(mag, magErr);
}

lsst::daf::base::DateTime lsst.afw.image::Calib::getMidTime

(

)

const

Return the time at the middle of an exposure

Definition at line 219 of file Calib.cc.

{
    return _midTime;
}

lsst::daf::base::DateTime lsst.afw.image::Calib::getMidTime	(	boost::shared_ptr< const lsst::afw::cameraGeom::Detector >	,
		lsst::afw::geom::Point2I const &
	)		const

Return the time at the middle of an exposure at the specified position in the focal plane (as described by a cameraGeom::Detector)

Warning

This implementation ignores its arguments!

Definition at line 230 of file Calib.cc.

{
    return _midTime;
}

std::string lsst.afw.image::Calib::getPersistenceName ( ) const

protectedvirtual

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 535 of file Calib.cc.

{ return getCalibPersistenceName(); }

bool lsst.afw.image::Calib::getThrowOnNegativeFlux ( )

static

Tell me whether Calib will throw an exception if asked to convert a flux to a magnitude

Definition at line 148 of file Calib.cc.

{
    return _throwOnNegativeFlux;
}

bool lsst.afw.image::Calib::isPersistable ( ) const

inlinevirtual

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

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

Definition at line 133 of file Calib.h.

{ return true; }

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

inline

Definition at line 131 of file Calib.h.

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

bool lsst.afw.image::Calib::operator==

(

Calib const &

rhs

)

const

Are two Calibs identical?

Note

Maybe this should be an approximate comparison

Definition at line 197 of file Calib.cc.

                                             {
    return
        ::fabs(_midTime.get() - rhs._midTime.get()) < std::numeric_limits<double>::epsilon() &&
        _exptime == rhs._exptime &&
        _fluxMag0 == rhs._fluxMag0 &&
        _fluxMag0Sigma == rhs._fluxMag0Sigma;
}

void lsst.afw.image::Calib::setExptime

(

double

exptime

)

Set the length of an exposure

Parameters

exptime

the length of the exposure (s)

Definition at line 241 of file Calib.cc.

                         {
    _exptime = exptime;
}

void lsst.afw.image::Calib::setFluxMag0	(	double	fluxMag0,
		double	fluxMag0Sigma = 0.0
	)

Set the flux of a zero-magnitude object

Parameters

fluxMag0	The flux in question (ADUs)
fluxMag0Sigma	The error in the flux (ADUs)

Definition at line 257 of file Calib.cc.

{
    _fluxMag0 = fluxMag0;
    _fluxMag0Sigma = fluxMag0Sigma;
}

void lsst.afw.image::Calib::setFluxMag0

(

std::pair< double, double >

fluxMag0AndSigma

)

Parameters

fluxMag0AndSigma

The flux and error (ADUs)

Definition at line 264 of file Calib.cc.

{
    _fluxMag0 = fluxMag0AndSigma.first;
    _fluxMag0Sigma = fluxMag0AndSigma.second;
}

void lsst.afw.image::Calib::setMidTime

(

lsst::daf::base::DateTime const &

midTime

)

Set the time of the middle of an exposure

Note

In general this is a function of position of the position of the detector in the focal plane

Parameters

midTime

Time at middle of exposure

Definition at line 210 of file Calib.cc.

{
    _midTime = midTime;
}

void lsst.afw.image::Calib::setThrowOnNegativeFlux ( bool  raiseException )

static

Set whether Calib should throw an exception when asked to convert a flux to a magnitude

Parameters

raiseException

Should the exception be raised?

Definition at line 138 of file Calib.cc.

{
    _throwOnNegativeFlux = raiseException;
}

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

protectedvirtual

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 537 of file Calib.cc.

                                                    {
    CalibSchema const & keys = CalibSchema::get();
    table::BaseCatalog cat = handle.makeCatalog(keys.schema);
    PTR(table::BaseRecord) record = cat.addNew();
    record->set(keys.midTime, getMidTime().nsecs());
    record->set(keys.expTime, getExptime());
    std::pair<double,double> fluxMag0 = getFluxMag0();
    record->set(keys.fluxMag0, fluxMag0.first);
    record->set(keys.fluxMag0Sigma, fluxMag0.second);
    handle.saveCatalog(cat);
}

Member Data Documentation

double lsst.afw.image::Calib::_exptime

private

Definition at line 143 of file Calib.h.

double lsst.afw.image::Calib::_fluxMag0

private

Definition at line 144 of file Calib.h.

double lsst.afw.image::Calib::_fluxMag0Sigma

private

Definition at line 145 of file Calib.h.

lsst::daf::base::DateTime lsst.afw.image::Calib::_midTime

private

Definition at line 142 of file Calib.h.

bool lsst.afw.image::Calib::_throwOnNegativeFlux = true

staticprivate

Control whether we throw an exception when faced with a negative flux

Definition at line 146 of file Calib.h.

---

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

• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/image/Calib.h
• /home/lsstsw/stack/Linux64/afw/11.0.rc2+4/src/image/Calib.cc