lsst::meas::extensions::trailedSources::VeresModel Class Reference

Implementation of an axisymmetric 2D Gaussian convolved with a line – a model for a fast-moving, trailed-source (Veres et al. More...

#include <VeresModel.h>

Public Types
using	ImageF = afw::image::Image<float>
using	ExposureF = afw::image::Exposure<float>

Public Member Functions
	VeresModel (ExposureF const &data)
	Constructor for VeresModel.
	VeresModel (VeresModel const &)=default
	VeresModel (VeresModel &&)=default
VeresModel &	operator= (VeresModel const &)=default
VeresModel &	operator= (VeresModel &&)=default
	~VeresModel ()=default
double	operator() (std::vector< double > const &params) const
	Compute chi-squared of the model given the data.
std::vector< double >	gradient (std::vector< double > const &params) const
	Compute the gradient of chi-squared of the model given the data.
std::tuple< double, std::vector< double > >	computeFluxWithGradient (std::vector< double > const &params) const
	Computes the flux and the gradient with respect to the other model parameters.
std::shared_ptr< ImageF >	computeModelImage (std::vector< double > const &params) const
	Compute an image for a trail generated from the Veres model.
double	getSigma () const noexcept
	Return the PSF sigma.

Detailed Description

Implementation of an axisymmetric 2D Gaussian convolved with a line – a model for a fast-moving, trailed-source (Veres et al.

2012).

VeresModel is designed to compute the chi-squared of the model given an lsst::afw::image::Exposure.

Definition at line 47 of file VeresModel.h.

Member Typedef Documentation

ExposureF

using lsst::meas::extensions::trailedSources::VeresModel::ExposureF = afw::image::Exposure<float>

Definition at line 50 of file VeresModel.h.

ImageF

using lsst::meas::extensions::trailedSources::VeresModel::ImageF = afw::image::Image<float>

Definition at line 49 of file VeresModel.h.

Constructor & Destructor Documentation

VeresModel() [1/3]

lsst::meas::extensions::trailedSources::VeresModel::VeresModel ( ExposureF const & data )

explicit

Constructor for VeresModel.

Parameters

data	Exposure passed from the measurement task.

Definition at line 39 of file VeresModel.cc.

  : _sigma(data.getPsf()->computeShape(data.getPsf()->getAveragePosition()).getTraceRadius()),
    _bbox(data.getBBox()),
    _data(data.getMaskedImage().getImage()->getArray()),
    _variance(data.getMaskedImage().getVariance()->getArray()) {}

VeresModel() [2/3]

lsst::meas::extensions::trailedSources::VeresModel::VeresModel ( VeresModel const & )

default

VeresModel() [3/3]

lsst::meas::extensions::trailedSources::VeresModel::VeresModel ( VeresModel && )

default

~VeresModel()

lsst::meas::extensions::trailedSources::VeresModel::~VeresModel ( )

default

Member Function Documentation

computeFluxWithGradient()

std::tuple< double, std::vector< double > > lsst::meas::extensions::trailedSources::VeresModel::computeFluxWithGradient

(

std::vector< double > const &

params

)

const

Computes the flux and the gradient with respect to the other model parameters.

We estimate the flux by solving the linear least-squares problem for the Veres et al. 2012 model. By keeping the length, angle, and centroid coordinates fixed, we analytically solve for the flux.

Parameters

params

Model parameters.

Returns

The flux and the gradient with respect to the model parameters.

Note

The params vector contains the following model parameters:

• Centroid x: X-coordinate of the centroid in given image [pixels].
• Centroid y: Y-coordinate of the centroid in given image [pixels].
• Flux: Total flux in the trail [count].
• Length: Length of the trail [pixels].
• Angle: Angle from the +x-axis [radians].

Definition at line 95 of file VeresModel.cc.

                                                                                                             {
 
    double xc = params[0];     // Centroid x
    double yc = params[1];     // Centroid y
    // double flux = params[2];   // Flux (in this case, always 1)
    double length = params[3]; // Trail length
    double theta = params[4];  // Angle from +x-axis
 
    // Compute the flux and gradient wrt the other model parameters
    double m2 = 0.0;  // sum_i model_i*model_i
    double md = 0.0;  // sum_i model_i*data_i
    std::vector<double> gradmd = {0.0, 0.0, 0.0, 0.0, 0.0};  // sum_i (gradModel_(i,k)*data_i)
    std::vector<double> gradmm = {0.0, 0.0, 0.0, 0.0, 0.0};  // sum_i (gradModel_(i,k)*model_i)
    for (int yIndex = 0, yp = _bbox.getBeginY(); yIndex < _bbox.getHeight(); ++yIndex, ++yp) {
        ImageF::Array::Reference dataRow = _data[yIndex];
        for (int xIndex = 0, xp = _bbox.getBeginX(); xIndex < _bbox.getWidth(); ++xIndex, ++xp) {
            double data = dataRow[xIndex];
            double model = _computeModel(xp, yp, xc, yc, 1.0, length, theta);
            std::array<double, 5> gradModel = _computeGradient(xp, yp, xc, yc, 1.0, length, theta);
            m2 += model*model;
            md += model*dataRow[xIndex];
            for (int k=0; k<5; ++k) {
                gradmd[k] += gradModel[k] * data;
                gradmm[k] += gradModel[k] * model;
            }
        }
    }
    double flux = md / m2;
    std::vector<double> gradFlux = {0.0, 0.0, 0.0, 0.0, 0.0};
    for (int k=0; k<5; ++k) {
        gradFlux[k] = (gradmd[k] - 2.0*flux*gradmm[k]) / m2;
    }
    gradFlux[2] = 0.0;  // Make dfluxdflux = 0
    std::tuple<double, std::vector<double>> results = std::make_tuple(flux, gradFlux);
    return results;
}

computeModelImage()

std::shared_ptr< ImageF > lsst::meas::extensions::trailedSources::VeresModel::computeModelImage

(

std::vector< double > const &

params

)

const

Compute an image for a trail generated from the Veres model.

Definition at line 132 of file VeresModel.cc.

                                                                                         {
    double xc = params[0];     // Centroid x
    double yc = params[1];     // Centroid y
    double flux = params[2];   // Flux
    double length = params[3]; // Trail length
    double theta = params[4];  // Angle from +x-axis
 
    // Loop is adapted from lsst::afw::detection::GaussianPsf::doComputeKernelImage()
    std::shared_ptr<ImageF> image(new ImageF(_bbox));
    ImageF::Array array = image->getArray();
    for (int yIndex = 0, yp = _bbox.getBeginY(); yIndex < _bbox.getHeight(); ++yIndex, ++yp) {
        ImageF::Array::Reference row = array[yIndex];
        for (int xIndex = 0, xp = _bbox.getBeginX(); xIndex < _bbox.getWidth(); ++xIndex, ++xp) {
            row[xIndex] = _computeModel(xp,yp,xc,yc,flux,length,theta);
        }
    }
    return image;
}

getSigma()

double lsst::meas::extensions::trailedSources::VeresModel::getSigma ( ) const

inlinenoexcept

Return the PSF sigma.

Definition at line 122 of file VeresModel.h.

{ return _sigma; }

gradient()

std::vector< double > lsst::meas::extensions::trailedSources::VeresModel::gradient

(

std::vector< double > const &

params

)

const

Compute the gradient of chi-squared of the model given the data.

Parameters

params

Model parameters.

Returns

The gradient of chi-squared of the model with respect to the model parameters.

Note

The params vector contains the following model parameters:

• Centroid x: X-coordinate of the centroid in given image [pixels].
• Centroid y: Y-coordinate of the centroid in given image [pixels].
• Flux: Total flux in the trail [count].
• Length: Length of the trail [pixels].
• Angle: Angle from the +x-axis [radians].

Definition at line 70 of file VeresModel.cc.

                                                                            {
 
    double xc = params[0];     // Centroid x
    double yc = params[1];     // Centroid y
    double flux = params[2];   // Flux
    double length = params[3]; // Trail length
    double theta = params[4];  // Angle from +x-axis
 
    // Compute gradients of the model and of chi-squared
    std::vector<double> gradChiSq = {0.0,0.0,0.0,0.0,0.0};
    for (int yIndex = 0, yp = _bbox.getBeginY(); yIndex < _bbox.getHeight(); ++yIndex, ++yp) {
        ImageF::Array::Reference dataRow = _data[yIndex];
        ImageF::Array::Reference varRow = _variance[yIndex];
        for (int xIndex = 0, xp = _bbox.getBeginX(); xIndex < _bbox.getWidth(); ++xIndex, ++xp) {
            double model = _computeModel(xp,yp,xc,yc,flux,length,theta);
            double gradDiff = -2.0 * (dataRow[xIndex] - model) / varRow[xIndex];
            std::array<double, 5> gradModel = _computeGradient(xp,yp,xc,yc,flux,length,theta);
            for (int k=0; k<5; ++k) {
                gradChiSq[k] += gradModel[k] * gradDiff;
            }
        }
    }
    return gradChiSq;
}

operator()()

double lsst::meas::extensions::trailedSources::VeresModel::operator()

(

std::vector< double > const &

params

)

const

Compute chi-squared of the model given the data.

Parameters

params

Model parameters.

Returns

The chi-squared of the model.

Note

The params vector contains the following model parameters:

• Centroid x: X-coordinate of the centroid in given image [pixels].
• Centroid y: Y-coordinate of the centroid in given image [pixels].
• Flux: Total flux in the trail [count].
• Length: Length of the trail [pixels].
• Angle: Angle from the +x-axis [radians].

Definition at line 46 of file VeresModel.cc.

                                                                   {
 
    double xc = params[0];     // Centroid x
    double yc = params[1];     // Centroid y
    double flux = params[2];   // Flux
    double length = params[3]; // Trail length
    double theta = params[4];  // Angle from +x-axis
 
    // Compute model image and chi-squared
    double chiSq = 0.0;
    // Loop is adapted from lsst::afw::detection::Psf::computeKernelImage()
    for (int yIndex = 0, yp = _bbox.getBeginY(); yIndex < _bbox.getHeight(); ++yIndex, ++yp) {
        ImageF::Array::Reference dataRow = _data[yIndex];
        ImageF::Array::Reference varRow = _variance[yIndex];
        for (int xIndex = 0, xp = _bbox.getBeginX(); xIndex < _bbox.getWidth(); ++xIndex, ++xp) {
            double model = _computeModel(xp,yp,xc,yc,flux,length,theta);
            double diff = dataRow[xIndex] - model;
            chiSq += diff*diff/varRow[xIndex];
        }
    }
 
    return chiSq;
}

operator=() [1/2]

VeresModel & lsst::meas::extensions::trailedSources::VeresModel::operator= ( VeresModel && )

default

operator=() [2/2]

VeresModel & lsst::meas::extensions::trailedSources::VeresModel::operator= ( VeresModel const & )

default

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_extensions_trailedSources/g3ddfee87b4+a761f810f3/include/lsst/meas/extensions/trailedSources/VeresModel.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/meas_extensions_trailedSources/g3ddfee87b4+a761f810f3/src/VeresModel.cc