lsst::meas::algorithms::shapelet::Legendre2D Class Reference

#include <Legendre2D.h>

Inheritance diagram for lsst::meas::algorithms::shapelet::Legendre2D:

Public Member Functions
	Legendre2D ()
	Legendre2D (double xMin, double xMax, double yMin, double yMax)
	Legendre2D (const Bounds &b)
	Legendre2D (const Legendre2D &rhs)
	Legendre2D (const Bounds &b, const DMatrix &a)
	Legendre2D (int xo, int yo, const Bounds &b)
	Legendre2D (std::istream &fin)
virtual	~Legendre2D ()
virtual void	write (std::ostream &fout) const
virtual std::auto_ptr< Function2D >	dFdX () const
virtual std::auto_ptr< Function2D >	dFdY () const
virtual std::auto_ptr< Function2D >	copy () const
virtual void	addLinear (double a, double b, double c)
virtual void	linearPreTransform (double a, double b, double c, double d, double e, double f)
virtual void	operator+= (const Function2D &rhs)
double	getXMin () const
double	getXMax () const
double	getYMin () const
double	getYMax () const
const Bounds &	getBounds () const
virtual void	setFunction (int xorder, int yorder, const DVector &fvect)
Public Member Functions inherited from lsst::meas::algorithms::shapelet::Function2D
	Function2D ()
	Function2D (int xo, int yo)
	Function2D (int xo, int yo, const DMatrix &c)
	Function2D (const Function2D &rhs)
virtual	~Function2D ()
virtual std::auto_ptr< Function2D >	conj () const
virtual void	operator*= (double scale)
virtual double	operator() (double x, double y) const
double	operator() (const Position &p) const
virtual void	setTo (double value)
bool	isNonZero () const
int	getXOrder () const
int	getYOrder () const
const DMatrix &	getCoeffs () const
virtual void	simpleFit (int order, const std::vector< Position > &pos, const std::vector< double > &v, const std::vector< bool > &shouldUse, const std::vector< double > *sigList=0, double *chisqOut=0, int *dofOut=0, DMatrix *cov=0)
virtual void	outlierFit (int order, double nsig, const std::vector< Position > &pos, const std::vector< double > &v, std::vector< bool > *shouldUse, const std::vector< double > *sigList=0, double *chisqout=0, int *dofout=0, DMatrix *cov=0)
virtual void	orderFit (int maxOrder, double equivProb, const std::vector< Position > &pos, const std::vector< double > &v, const std::vector< bool > &shouldUse, const std::vector< double > *sigList=0, double *chisqout=0, int *dofout=0, DMatrix *cov=0)
virtual void	linearTransform (double a, double b, double c, const Function2D &f, const Function2D &g)
virtual void	linearTransform (double a, double b, const Function2D &f)

Private Member Functions
DVector	definePXY (int order, double xy, double min, double max) const
virtual DVector	definePX (int order, double x) const
virtual DVector	definePY (int order, double y) const

Private Attributes
Bounds	_bounds

Additional Inherited Members
Static Public Member Functions inherited from lsst::meas::algorithms::shapelet::Function2D
static std::auto_ptr< Function2D >	read (std::istream &fin)
Protected Attributes inherited from lsst::meas::algorithms::shapelet::Function2D
int	_xOrder
int	_yOrder
std::auto_ptr< DMatrix >	_coeffs

Detailed Description

Definition at line 12 of file Legendre2D.h.

Constructor & Destructor Documentation

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( )

inline

Definition at line 17 of file Legendre2D.h.

{}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( double  xMin, double  xMax, double  yMin, double  yMax  )

inline

Definition at line 19 of file Legendre2D.h.

                                                                    :
            Function2D(), _bounds(xMin,xMax,yMin,yMax) {}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( const Bounds &  b )

inline

Definition at line 22 of file Legendre2D.h.

: Function2D(), _bounds(b) {}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( const Legendre2D &  rhs )

inline

Definition at line 24 of file Legendre2D.h.

                                          :
            Function2D(rhs), _bounds(rhs._bounds) {}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( const Bounds &  b, const DMatrix &  a  )

inline

Definition at line 27 of file Legendre2D.h.

                                                      : 
            Function2D(a.TMV_colsize()-1,a.TMV_rowsize()-1,a), _bounds(b) {}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D ( int  xo, int  yo, const Bounds &  b  )

inline

Definition at line 30 of file Legendre2D.h.

                                                    :
            Function2D(xo,yo), _bounds(b) {}

lsst::meas::algorithms::shapelet::Legendre2D::Legendre2D

(

std::istream &

fin

)

Definition at line 68 of file Legendre2D.cc.

                                          : Function2D()
    {
        // Order of parameters is same as for Polynomial2D.  Difference
        // is that instead of x,x^2,x^3,etc., we use P1(x),P2(x),P3(x),etc.
        fin >> _xOrder >> _yOrder >> _bounds;
        if (!fin) throw std::runtime_error("reading order, bounds");
        _coeffs.reset(new DMatrix(_xOrder+1,_yOrder+1));
        _coeffs->setZero();
        int maxOrder = std::max(_xOrder,_yOrder);
        for(int m=0; m<=maxOrder; ++m) {
            for(int i=std::min(m,_xOrder); m-i<=std::min(m,_yOrder); --i) {
                fin >> (*_coeffs)(i,m-i);
            }
        }
        if (!fin) throw std::runtime_error("reading (legendre) function");
    }

virtual lsst::meas::algorithms::shapelet::Legendre2D::~Legendre2D ( )

inlinevirtual

Definition at line 35 of file Legendre2D.h.

{}

Member Function Documentation

void lsst::meas::algorithms::shapelet::Legendre2D::addLinear ( double  a, double  b, double  c  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 107 of file Legendre2D.cc.

    {
        double xAve = (getXMin() + getXMax())/2.;
        double yAve = (getYMin() + getYMax())/2.;
        double xRange = getXMax() - getXMin();
        double yRange = getYMax() - getYMin();

        (*_coeffs)(0,0) += a + b*xAve + c*yAve;
        (*_coeffs)(1,0) += b*xRange/2.;
        (*_coeffs)(0,1) += c*yRange/2.;
    }

virtual std::auto_ptr<Function2D> lsst::meas::algorithms::shapelet::Legendre2D::copy ( ) const

inlinevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 43 of file Legendre2D.h.

        { return std::auto_ptr<Function2D>(new Legendre2D(*this)); }

DVector lsst::meas::algorithms::shapelet::Legendre2D::definePX ( int  order, double  x  ) const

privatevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 238 of file Legendre2D.cc.

    {
        if (x < getXMin() || x > getXMax()) {
            dbg<<"Error: x = "<<x<<
                ", min,max = "<<getXMin()<<','<<getXMax()<<std::endl;
            throw RangeException(Position(x,getYMin()),_bounds);
        }
        return definePXY(order,x,getXMin(),getXMax());
    }

DVector lsst::meas::algorithms::shapelet::Legendre2D::definePXY ( int  order, double  xy, double  min, double  max  ) const

private

Definition at line 227 of file Legendre2D.cc.

    {
        DVector temp(order+1);
        double xyNew = (2.*xy-min-max)/(max-min);
        temp[0] = 1.; if(order>0) temp[1] = xyNew;
        for(int i=2;i<=order;++i)
            temp[i] = ((2.*i-1.)*xyNew*temp[i-1] - (i-1.)*temp[i-2])/i;
        return temp;
    }

DVector lsst::meas::algorithms::shapelet::Legendre2D::definePY ( int  order, double  y  ) const

privatevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 248 of file Legendre2D.cc.

    {
        if (y < getYMin() || y > getYMax()) {
            dbg<<"Error: y = "<<y<<
                ", min,max = "<<getYMin()<<','<<getYMax()<<std::endl;
            throw RangeException(Position(getXMin(),y),_bounds);
        }
        return definePXY(order,y,getYMin(),getYMax());
    }

std::auto_ptr< Function2D > lsst::meas::algorithms::shapelet::Legendre2D::dFdX ( ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 149 of file Legendre2D.cc.

    {
        if (_xOrder == 0) {
            return std::auto_ptr<Function2D >(new Constant2D());
        }
        if (_xOrder == 1 && _yOrder == 0) {
            return std::auto_ptr<Function2D >(
                new Constant2D((*_coeffs)(1,0)*2./(getXMax()-getXMin())));
        }

        int newXOrder = _xOrder-1;
        int newYOrder = _xOrder > _yOrder ? _yOrder : _yOrder-1;

        std::auto_ptr<Legendre2D > temp(
            new Legendre2D(newXOrder,newYOrder,_bounds));
        // initialized to 0's

        int maxOrder = std::max(_xOrder,_yOrder);
        for(int i=_xOrder;i>=1;--i) {
            for(int j=std::min(maxOrder-i,_yOrder);j>=0;--j) {
                if (i%2 == 0) {
                    for(int k=0;k<=i/2-1;++k) 
                        (*temp->_coeffs)(2*k+1,j) += (4.*k+3.)*(*_coeffs)(i,j);
                } else  {
                    for(int k=0;k<=(i-1)/2;++k) 
                        (*temp->_coeffs)(2*k,j) += (4.*k+1.)*(*_coeffs)(i,j);
                }
            }
        }
        maxOrder = std::max(newXOrder,newYOrder);
        for(int i=newXOrder;i>=0;--i) {
            for(int j=std::min(maxOrder-i,newYOrder);j>=0;--j) {
                (*temp->_coeffs)(i,j) *= 2./(getXMax()-getXMin());
            }
        }
        return std::auto_ptr<Function2D >(temp);
    }

std::auto_ptr< Function2D > lsst::meas::algorithms::shapelet::Legendre2D::dFdY ( ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 189 of file Legendre2D.cc.

    {
        if (_yOrder == 0) {
            return std::auto_ptr<Function2D >(new Constant2D());
        }
        if (_yOrder == 1 && _xOrder == 0) {
            return std::auto_ptr<Function2D >(new Constant2D(
                    (*_coeffs)(0,1)*2./(getYMax()-getYMin())));
        }

        int newXOrder = _yOrder > _xOrder ? _xOrder : _xOrder-1;
        int newYOrder = _yOrder-1;

        std::auto_ptr<Legendre2D > temp(
            new Legendre2D(newXOrder,newYOrder,_bounds));
        // initialized to 0's

        int maxOrder = std::max(_xOrder,_yOrder);
        for(int j=_yOrder;j>=1;--j) {
            for(int i=std::min(maxOrder-j,_xOrder);i>=0;--i) {
                if (j%2 == 0) {
                    for(int k=0;k<=(j-2)/2;++k) 
                        (*temp->_coeffs)(i,2*k+1) += (4.*k+3.)*(*_coeffs)(i,j);
                } else {
                    for(int k=0;k<=(j-1)/2;++k) 
                        (*temp->_coeffs)(i,2*k) += (4.*k+1.)*(*_coeffs)(i,j);
                }
            }
        }
        maxOrder = std::max(newXOrder,newYOrder);
        for(int j=newYOrder;j>=0;--j) {
            for(int i=std::min(maxOrder-j,newXOrder);i>=0;--i) {
                (*temp->_coeffs)(i,j) *= 2./(getYMax()-getYMin());
            }
        }
        return std::auto_ptr<Function2D >(temp);
    }

const Bounds& lsst::meas::algorithms::shapelet::Legendre2D::getBounds ( ) const

inline

Definition at line 61 of file Legendre2D.h.

{return _bounds;}

double lsst::meas::algorithms::shapelet::Legendre2D::getXMax ( ) const

inline

Definition at line 55 of file Legendre2D.h.

{return _bounds.getXMax();}

double lsst::meas::algorithms::shapelet::Legendre2D::getXMin ( ) const

inline

Definition at line 53 of file Legendre2D.h.

{return _bounds.getXMin();}

double lsst::meas::algorithms::shapelet::Legendre2D::getYMax ( ) const

inline

Definition at line 59 of file Legendre2D.h.

{return _bounds.getYMax();}

double lsst::meas::algorithms::shapelet::Legendre2D::getYMin ( ) const

inline

Definition at line 57 of file Legendre2D.h.

{return _bounds.getYMin();}

void lsst::meas::algorithms::shapelet::Legendre2D::linearPreTransform ( double  a, double  b, double  c, double  d, double  e, double  f  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 119 of file Legendre2D.cc.

    {
        // Not implemented yet.
        Assert(false);
    }

void lsst::meas::algorithms::shapelet::Legendre2D::operator+= ( const Function2D &  rhs )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 126 of file Legendre2D.cc.

    {
        const Legendre2D* lrhs = dynamic_cast<const Legendre2D*>(&rhs);
        Assert(lrhs);
        Assert(getBounds() == lrhs->getBounds());
        if (_xOrder == lrhs->_xOrder && _yOrder == lrhs->_yOrder) {
            *_coeffs += *lrhs->_coeffs;
        } else {
            int newXOrder = std::max(_xOrder,lrhs->_xOrder);
            int newYOrder = std::max(_yOrder,lrhs->_yOrder);
            std::auto_ptr<DMatrix > newc(
                new DMatrix(newXOrder+1,newYOrder+1));
            newc->setZero();
            newc->TMV_subMatrix(0,_xOrder+1,0,_yOrder+1) = *_coeffs;
            newc->TMV_subMatrix(0,lrhs->_xOrder+1,0,lrhs->_yOrder+1) += *lrhs->_coeffs;
            _coeffs = newc;
            _xOrder = newXOrder;
            _yOrder = newYOrder;
        }
    }

void lsst::meas::algorithms::shapelet::Legendre2D::setFunction ( int  xorder, int  yorder, const DVector &  fvect  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 51 of file Legendre2D.cc.

    {
        if (_xOrder != xOrder || _yOrder != yOrder) {
            _xOrder = xOrder; _yOrder = yOrder;
            _coeffs.reset(new DMatrix(_xOrder+1,_yOrder+1));
            _coeffs->setZero();
        }
        int k=0;
        for(int m=0; m <= std::max(_xOrder,_yOrder); ++m) {
            for(int i=std::min(m,_xOrder);m-i<=std::min(m,_yOrder);--i) { 
                (*_coeffs)(i,m-i) = fVect(k++);
            }
        }
        Assert(k==(int)fVect.size());
    }

void lsst::meas::algorithms::shapelet::Legendre2D::write ( std::ostream &  fout ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 85 of file Legendre2D.cc.

    {
        int oldprec = fout.precision(6);
        std::ios::fmtflags oldf = 
            fout.setf(std::ios::scientific,std::ios::floatfield);
        int maxOrder = std::max(_xOrder,_yOrder);
        if (maxOrder == 0) {
            fout << "C " << (*_coeffs)(0,0) << std::endl;
        } else {
            fout << "L " << _xOrder << ' ' << _yOrder << ' ' << _bounds << ' ';
            for(int m=0; m<=maxOrder; ++m) {
                for(int i=std::min(m,_xOrder);m-i<=std::min(m,_yOrder);--i) {
                    fout << (*_coeffs)(i,m-i) << ' ';
                }
            }
            fout << std::endl;
        }
        if (!fout) throw std::runtime_error("writing (legendre) function");
        fout.precision(oldprec);
        fout.flags(oldf);
    }

Member Data Documentation

Bounds lsst::meas::algorithms::shapelet::Legendre2D::_bounds

private

Definition at line 68 of file Legendre2D.h.

---

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

• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/include/lsst/meas/algorithms/shapelet/Legendre2D.h
• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/src/shapelet/Legendre2D.cc