lsst::jointcal::TanPix2RaDec Class Reference

the transformation that handles pix to sideral transfos (Gnomonic, possibly with polynomial distortions). More...

#include <Gtransfo.h>

Inheritance diagram for lsst::jointcal::TanPix2RaDec:

Public Member Functions
	TanPix2RaDec (GtransfoLin const &pix2Tan, Point const &tangentPoint, const GtransfoPoly *corrections=nullptr)
	pix2Tan describes the transfo from pix to tangent plane (degrees). More...
GtransfoPoly	getPix2TangentPlane () const
	the transformation from pixels to tangent plane (degrees) More...
virtual void	pix2TP (double xPixel, double yPixel, double &xTangentPlane, double &yTangentPlane) const
	transforms from pixel space to tangent plane (degrees) More...
	TanPix2RaDec ()
TanPix2RaDec	operator* (GtransfoLin const &right) const
	composition with GtransfoLin More...
std::unique_ptr< Gtransfo >	composeAndReduce (GtransfoLin const &right) const
	Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced. More...
TanRaDec2Pix	inverted () const
	approximate inverse : it ignores corrections; More...
std::unique_ptr< Gtransfo >	roughInverse (const Frame &region) const
	Overload the "generic routine" (available for all Gtransfo types. More...
std::unique_ptr< Gtransfo >	inverseTransfo (const double precision, const Frame &region) const
	Inverse transfo: returns a TanRaDec2Pix if there are no corrections, or the iterative solver if there are. More...
std::unique_ptr< Gtransfo >	clone () const
	returns a copy (allocated by new) of the transformation. More...
void	dump (std::ostream &stream) const
	dumps the transfo coefficients to stream. More...
double	fit (StarMatchList const &starMatchList)
	Not implemented yet, because we do it otherwise. More...
void	apply (const double xIn, const double yIn, double &xOut, double &yOut) const
	Transform pixels to ICRS RA, Dec in degrees. More...
void	apply (Point const &in, Point &out) const
	applies the tranfo to in and writes into out. Is indeed virtual. More...
Point	apply (Point const &in) const
	All these apply(..) shadow the virtual one in derived classes, unless one writes "using Gtransfo::apply". More...
Frame	apply (Frame const &inputframe, bool inscribed) const
	Transform a bounding box, taking either the inscribed or circumscribed box. More...
Point	getTangentPoint () const
	Get the sky origin (CRVAL in FITS WCS terminology) in degrees. More...
GtransfoLin	getLinPart () const
	The Linear part (corresponding to CD's and CRPIX's) More...
const GtransfoPoly *	getCorr () const
	Get a non-owning pointer to the correction transform polynomial. More...
void	setCorrections (std::unique_ptr< GtransfoPoly > corrections)
	Assign the correction polynomial (what it means is left to derived classes) More...
Point	getCrPix () const
	Get the pixel origin of the WCS (CRPIX in FITS WCS terminology, but zero-based) More...
std::string	__str__ ()
void	transformStar (FatPoint &in) const
	allows to write MyTransfo(MyStar) More...
virtual double	getJacobian (Point const &point) const
	returns the local jacobian. More...
virtual double	getJacobian (const double x, const double y) const
	returns the local jacobian. More...
virtual std::unique_ptr< Gtransfo >	composeAndReduce (Gtransfo const &right) const
	Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced. More...
virtual void	computeDerivative (Point const &where, GtransfoLin &derivative, const double step=0.01) const
	Computes the local Derivative of a transfo, w.r.t. More...
virtual GtransfoLin	linearApproximation (Point const &where, const double step=0.01) const
	linear (local) approximation. More...
virtual void	transformPosAndErrors (const FatPoint &in, FatPoint &out) const
virtual void	transformErrors (Point const &where, const double *vIn, double *vOut) const
	transform errors (represented as double[3] in order V(xx),V(yy),Cov(xy)) More...
void	getParams (double *params) const
	params should be at least Npar() long More...
void	offsetParams (Eigen::VectorXd const &delta)
virtual double	paramRef (const int i) const
virtual double &	paramRef (const int i)
virtual void	paramDerivatives (Point const &where, double *dx, double *dy) const
	Derivative w.r.t parameters. More...
virtual int	getNpar () const
	returns the number of parameters (to compute chi2's) More...
virtual std::shared_ptr< ast::Mapping >	toAstMap (jointcal::Frame const &domain) const
	Create an equivalent AST mapping for this transformation, including an analytic inverse if possible. More...
void	write (const std::string &fileName) const
virtual void	write (std::ostream &stream) const

Protected Attributes
GtransfoLin	linPix2Tan
std::unique_ptr< GtransfoPoly >	corr
double	ra0
double	dec0
double	cos0
double	sin0

Detailed Description

the transformation that handles pix to sideral transfos (Gnomonic, possibly with polynomial distortions).

Definition at line 600 of file Gtransfo.h.

Constructor & Destructor Documentation

TanPix2RaDec() [1/2]

lsst::jointcal::TanPix2RaDec::TanPix2RaDec	(	GtransfoLin const &	pix2Tan,
		Point const &	tangentPoint,
		const GtransfoPoly *	corrections = nullptr
	)

pix2Tan describes the transfo from pix to tangent plane (degrees).

TangentPoint in degrees. Corrections are applied between Lin and deprojection parts (as in Swarp).

Definition at line 1417 of file Gtransfo.cc.

        : BaseTanWcs(pix2Tan, tangentPoint, corrections) {}

TanPix2RaDec() [2/2]

lsst::jointcal::TanPix2RaDec::TanPix2RaDec

(

)

Definition at line 1422 of file Gtransfo.cc.

: BaseTanWcs(GtransfoLin(), Point(0, 0), nullptr) {}

Member Function Documentation

__str__()

std::string lsst::jointcal::Gtransfo::__str__ ( )

inlineinherited

Definition at line 94 of file Gtransfo.h.

                        {
        std::stringstream s;
        dump(s);
        return s.str();
    }

apply() [1/4]

void lsst::jointcal::Gtransfo::apply ( Point const &  in, Point &  out  ) const

inlineinherited

applies the tranfo to in and writes into out. Is indeed virtual.

Definition at line 71 of file Gtransfo.h.

{ apply(in.x, in.y, out.x, out.y); }

apply() [2/4]

Point lsst::jointcal::Gtransfo::apply ( Point const &  in ) const

inlineinherited

All these apply(..) shadow the virtual one in derived classes, unless one writes "using Gtransfo::apply".

Definition at line 75 of file Gtransfo.h.

                                       {
        double xout, yout;
        apply(in.x, in.y, xout, yout);
        return Point(xout, yout);
    }

apply() [3/4]

Frame lsst::jointcal::Gtransfo::apply ( Frame const &  inputframe, bool  inscribed  ) const

inherited

Transform a bounding box, taking either the inscribed or circumscribed box.

Parameters

[in]	inputframe	The frame to be transformed.
[in]	inscribed	Return the inscribed (true) or circumscribed (false) box.

Returns

The transformed frame.

Definition at line 74 of file Gtransfo.cc.

                                                                   {
    // 2 opposite corners
    double xtmin1, xtmax1, ytmin1, ytmax1;
    apply(inputframe.xMin, inputframe.yMin, xtmin1, ytmin1);
    apply(inputframe.xMax, inputframe.yMax, xtmax1, ytmax1);
    Frame fr1(std::min(xtmin1, xtmax1), std::min(ytmin1, ytmax1), std::max(xtmin1, xtmax1),
              std::max(ytmin1, ytmax1));
    // 2 other corners
    double xtmin2, xtmax2, ytmin2, ytmax2;
    apply(inputframe.xMin, inputframe.yMax, xtmin2, ytmax2);
    apply(inputframe.xMax, inputframe.yMin, xtmax2, ytmin2);
    Frame fr2(std::min(xtmin2, xtmax2), std::min(ytmin2, ytmax2), std::max(xtmin2, xtmax2),
              std::max(ytmin2, ytmax2));

    if (inscribed) return fr1 * fr2;
    return fr1 + fr2;
}

apply() [4/4]

void lsst::jointcal::BaseTanWcs::apply ( const double  xIn, const double  yIn, double &  xOut, double &  yOut  ) const

virtualinherited

Transform pixels to ICRS RA, Dec in degrees.

Implements lsst::jointcal::Gtransfo.

Definition at line 1351 of file Gtransfo.cc.

                                                                                           {
    double l, m;             // radians in the tangent plane
    pix2TP(xIn, yIn, l, m);  // l, m in degrees.
    l = deg2rad(l);
    m = deg2rad(m);  // now in radians
                     // Code inspired from worldpos.c in wcssubs (ancestor of the wcslib)
                     /* At variance with wcslib, it collapses the projection to a plane
                        and expression of sidereal cooordinates into a single set of
                        operations. */
    double dect = cos0 - m * sin0;
    if (dect == 0) {
        LOGL_WARN(_log, "No sidereal coordinates at pole!");
        xOut = 0;
        yOut = 0;
        return;
    }
    double rat = ra0 + atan2(l, dect);
    dect = atan(std::cos(rat - ra0) * (m * cos0 + sin0) / dect);
    if (rat - ra0 > M_PI) rat -= (2. * M_PI);
    if (rat - ra0 < -M_PI) rat += (2. * M_PI);
    if (rat < 0.0) rat += (2. * M_PI);
    // convert to degree
    xOut = rad2deg(rat);
    yOut = rad2deg(dect);
}

clone()

std::unique_ptr< Gtransfo > lsst::jointcal::TanPix2RaDec::clone ( ) const

virtual

returns a copy (allocated by new) of the transformation.

Implements lsst::jointcal::Gtransfo.

Definition at line 1474 of file Gtransfo.cc.

                                                  {
    return std::unique_ptr<Gtransfo>(new TanPix2RaDec(getLinPart(), getTangentPoint(), corr.get()));
}

composeAndReduce() [1/2]

std::unique_ptr< Gtransfo > lsst::jointcal::Gtransfo::composeAndReduce ( Gtransfo const &  right ) const

virtualinherited

Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced.

"Reduced" in this context means that they are capable of being merged into a single transform, for example, for two polynomials:

\[ f(x) = 1 + x^2, g(x) = -1 + 3x \]

we would have h = f.composeAndReduce(g) == 2 - 6x + 9x^2.

To be overloaded by derived classes if they can properly reduce the composition.

Parameters

right

The transform to apply first.

Returns

The new reduced and composed gtransfo, or nullptr if no such reduction is possible.

Reimplemented in lsst::jointcal::GtransfoIdentity.

Definition at line 92 of file Gtransfo.cc.

                                {  // by default no way to compose
    return std::unique_ptr<Gtransfo>(nullptr);
}

composeAndReduce() [2/2]

std::unique_ptr< Gtransfo > lsst::jointcal::TanPix2RaDec::composeAndReduce

(

GtransfoLin const &

right

)

const

Return a reduced composition of newTransfo = this(right()), or nullptr if it cannot be reduced.

"Reduced" in this context means that they are capable of being merged into a single transform, for example, for two polynomials:

\[ f(x) = 1 + x^2, g(x) = -1 + 3x \]

we would have h = f.composeAndReduce(g) == 2 - 6x + 9x^2.

To be overloaded by derived classes if they can properly reduce the composition.

Parameters

right

The transform to apply first.

Returns

The new reduced and composed gtransfo, or nullptr if no such reduction is possible.

Definition at line 1424 of file Gtransfo.cc.

                                                                                     {
    if (right.getOrder() == 1) {
        return std::make_unique<TanPix2RaDec>((*this) * (right));
    } else {
        return std::unique_ptr<Gtransfo>(nullptr);
    }
}

computeDerivative()

void lsst::jointcal::Gtransfo::computeDerivative ( Point const &  where, GtransfoLin &  derivative, const double  step = 0.01  ) const

virtualinherited

Computes the local Derivative of a transfo, w.r.t.

the Derivative is represented by a GtransfoLin, in which (hopefully), the offset terms are zero.

position.

Step is used for numerical derivation.

Derivative should transform a vector of offsets into a vector of offsets.

Reimplemented in lsst::jointcal::GtransfoLin, lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 116 of file Gtransfo.cc.

                                                                                                     {
    double x = where.x;
    double y = where.y;
    double xp0, yp0;
    apply(x, y, xp0, yp0);

    double xp, yp;
    apply(x + step, y, xp, yp);
    derivative.a11() = (xp - xp0) / step;
    derivative.a21() = (yp - yp0) / step;
    apply(x, y + step, xp, yp);
    derivative.a12() = (xp - xp0) / step;
    derivative.a22() = (yp - yp0) / step;
    derivative.dx() = 0;
    derivative.dy() = 0;
}

dump()

void lsst::jointcal::TanPix2RaDec::dump ( std::ostream &  stream ) const

virtual

dumps the transfo coefficients to stream.

Implements lsst::jointcal::Gtransfo.

Definition at line 1478 of file Gtransfo.cc.

                                             {
    stream << " TanPix2RaDec, lin part :" << endl << linPix2Tan;
    Point tp = getTangentPoint();
    stream << " tangent point " << tp.x << ' ' << tp.y << endl;
    Point crpix = getCrPix();
    stream << " crpix " << crpix.x << ' ' << crpix.y << endl;
    if (corr) stream << "PV correction: " << endl << *corr;
}

fit()

double lsst::jointcal::TanPix2RaDec::fit ( StarMatchList const &  starMatchList )

virtual

Not implemented yet, because we do it otherwise.

Implements lsst::jointcal::Gtransfo.

Definition at line 1487 of file Gtransfo.cc.

                                              {
    /* OK we could implement this routine, but it is
       probably useless since to do the match, we have to
       project from sky to tangent plane. When a match is
       found, it is easier to carry out the fit in the
       tangent plane, rather than going back to the celestial
       sphere (and reproject to fit...). Anyway if this
       message shows up, we'll think about it.
    */
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "TanPix2RaDec::fit is NOT implemented (although it is doable)) ");
    return -1;
}

getCorr()

const GtransfoPoly* lsst::jointcal::BaseTanWcs::getCorr ( ) const

inlineinherited

Get a non-owning pointer to the correction transform polynomial.

Definition at line 572 of file Gtransfo.h.

{ return corr.get(); }

getCrPix()

Point lsst::jointcal::BaseTanWcs::getCrPix ( ) const

inherited

Get the pixel origin of the WCS (CRPIX in FITS WCS terminology, but zero-based)

Definition at line 1383 of file Gtransfo.cc.

                                 {
    /* CRPIX's are defined by:
                      ( CD1_1  CD1_2 )   (x - crpix1)
       transformed =  (              ) * (          )
                      ( CD2_1  CD2_2 )   (y - crpix2)

       so that CrPix is the point which transforms to (0,0)
    */
    const GtransfoLin inverse = linPix2Tan.inverted();
    return Point(inverse.Dx(), inverse.Dy());
}

getJacobian() [1/2]

virtual double lsst::jointcal::Gtransfo::getJacobian ( Point const &  point ) const

inlinevirtualinherited

returns the local jacobian.

Definition at line 111 of file Gtransfo.h.

{ return getJacobian(point.x, point.y); }

getJacobian() [2/2]

double lsst::jointcal::Gtransfo::getJacobian ( const double  x, const double  y  ) const

virtualinherited

returns the local jacobian.

Definition at line 97 of file Gtransfo.cc.

                                                                 {
    double x2, y2;
    double eps = x * 0.01;
    if (eps == 0) eps = 0.01;
    apply(x, y, x2, y2);
    double dxdx, dydx;
    apply(x + eps, y, dxdx, dydx);
    dxdx -= x2;
    dydx -= y2;
    double dxdy, dydy;
    apply(x, y + eps, dxdy, dydy);
    dxdy -= x2;
    dydy -= y2;
    return ((dxdx * dydy - dxdy * dydx) / (eps * eps));
}

getLinPart()

GtransfoLin lsst::jointcal::BaseTanWcs::getLinPart ( ) const

inherited

The Linear part (corresponding to CD's and CRPIX's)

Definition at line 1379 of file Gtransfo.cc.

{ return linPix2Tan; }

getNpar()

virtual int lsst::jointcal::Gtransfo::getNpar ( ) const

inlinevirtualinherited

returns the number of parameters (to compute chi2's)

Reimplemented in lsst::jointcal::GtransfoLinScale, lsst::jointcal::GtransfoLinRot, lsst::jointcal::GtransfoLinShift, lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 180 of file Gtransfo.h.

{ return 0; }

getParams()

void lsst::jointcal::Gtransfo::getParams ( double *  params ) const

inherited

params should be at least Npar() long

Definition at line 210 of file Gtransfo.cc.

                                             {
    int npar = getNpar();
    for (int i = 0; i < npar; ++i) params[i] = paramRef(i);
}

getPix2TangentPlane()

GtransfoPoly lsst::jointcal::TanPix2RaDec::getPix2TangentPlane ( ) const

virtual

the transformation from pixels to tangent plane (degrees)

Implements lsst::jointcal::BaseTanWcs.

Definition at line 1457 of file Gtransfo.cc.

                                                     {
    if (corr)
        return (*corr) * linPix2Tan;
    else
        return linPix2Tan;
}

getTangentPoint()

Point lsst::jointcal::BaseTanWcs::getTangentPoint ( ) const

inherited

Get the sky origin (CRVAL in FITS WCS terminology) in degrees.

Definition at line 1377 of file Gtransfo.cc.

{ return Point(rad2deg(ra0), rad2deg(dec0)); }

inverseTransfo()

std::unique_ptr< Gtransfo > lsst::jointcal::TanPix2RaDec::inverseTransfo ( const double  precision, const Frame &  region  ) const

virtual

Inverse transfo: returns a TanRaDec2Pix if there are no corrections, or the iterative solver if there are.

Reimplemented from lsst::jointcal::Gtransfo.

Definition at line 1450 of file Gtransfo.cc.

                                                                                                      {
    if (!corr)
        return std::unique_ptr<Gtransfo>(new TanRaDec2Pix(getLinPart().inverted(), getTangentPoint()));
    else
        return std::unique_ptr<Gtransfo>(new GtransfoInverse(this, precision, region));
}

inverted()

TanRaDec2Pix lsst::jointcal::TanPix2RaDec::inverted

(

)

const

approximate inverse : it ignores corrections;

Definition at line 1438 of file Gtransfo.cc.

                                          {
    if (corr != nullptr) {
        LOGL_WARN(_log, "You are inverting a TanPix2RaDec with corrections.");
        LOGL_WARN(_log, "The inverse you get ignores the corrections!");
    }
    return TanRaDec2Pix(getLinPart().inverted(), getTangentPoint());
}

linearApproximation()

GtransfoLin lsst::jointcal::Gtransfo::linearApproximation ( Point const &  where, const double  step = 0.01  ) const

virtualinherited

linear (local) approximation.

Reimplemented in lsst::jointcal::GtransfoLin, and lsst::jointcal::GtransfoIdentity.

Definition at line 133 of file Gtransfo.cc.

                                                                                     {
    Point outwhere = apply(where);
    GtransfoLin der;
    computeDerivative(where, der, step);
    return GtransfoLinShift(outwhere.x, outwhere.y) * der * GtransfoLinShift(-where.x, -where.y);
}

offsetParams()

void lsst::jointcal::Gtransfo::offsetParams ( Eigen::VectorXd const &  delta )

inherited

Definition at line 215 of file Gtransfo.cc.

                                                      {
    int npar = getNpar();
    for (int i = 0; i < npar; ++i) paramRef(i) += delta[i];
}

operator*()

TanPix2RaDec lsst::jointcal::TanPix2RaDec::operator*

(

GtransfoLin const &

right

)

const

composition with GtransfoLin

Definition at line 1432 of file Gtransfo.cc.

                                                                   {
    TanPix2RaDec result(*this);
    result.linPix2Tan = result.linPix2Tan * right;
    return result;
}

paramDerivatives()

void lsst::jointcal::Gtransfo::paramDerivatives ( Point const &  where, double *  dx, double *  dy  ) const

virtualinherited

Derivative w.r.t parameters.

Derivatives should be al least 2*NPar long. first Npar, for x, last Npar for y.

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 229 of file Gtransfo.cc.

                                                                       {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "Gtransfo::paramDerivatives() should never be called ");
}

paramRef() [1/2]

double lsst::jointcal::Gtransfo::paramRef ( const int  i ) const

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 220 of file Gtransfo.cc.

                                         {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      std::string("Gtransfo::paramRef should never be called "));
}

paramRef() [2/2]

double & lsst::jointcal::Gtransfo::paramRef ( const int  i )

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly.

Definition at line 225 of file Gtransfo.cc.

                                    {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError, "Gtransfo::paramRef should never be called ");
}

pix2TP()

void lsst::jointcal::TanPix2RaDec::pix2TP ( double  xPixel, double  yPixel, double &  xTangentPlane, double &  yTangentPlane  ) const

virtual

transforms from pixel space to tangent plane (degrees)

Implements lsst::jointcal::BaseTanWcs.

Definition at line 1464 of file Gtransfo.cc.

                                                                                                          {
    // xTangentPlane, yTangentPlane in degrees.
    linPix2Tan.apply(xPixel, yPixel, xTangentPlane, yTangentPlane);
    if (corr) {
        double xtmp = xTangentPlane;
        double ytmp = yTangentPlane;
        corr->apply(xtmp, ytmp, xTangentPlane, yTangentPlane);  // still in degrees.
    }
}

roughInverse()

std::unique_ptr< Gtransfo > lsst::jointcal::TanPix2RaDec::roughInverse ( const Frame &  region ) const

virtual

Overload the "generic routine" (available for all Gtransfo types.

Reimplemented from lsst::jointcal::Gtransfo.

Definition at line 1446 of file Gtransfo.cc.

                                                                      {
    return std::unique_ptr<Gtransfo>(new TanRaDec2Pix(getLinPart().inverted(), getTangentPoint()));
}

setCorrections()

void lsst::jointcal::BaseTanWcs::setCorrections ( std::unique_ptr< GtransfoPoly >  corrections )

inherited

Assign the correction polynomial (what it means is left to derived classes)

Definition at line 1381 of file Gtransfo.cc.

{ corr = std::move(corrections); }

toAstMap()

virtual std::shared_ptr<ast::Mapping> lsst::jointcal::Gtransfo::toAstMap ( jointcal::Frame const &  domain ) const

inlinevirtualinherited

Create an equivalent AST mapping for this transformation, including an analytic inverse if possible.

Parameters

domain

The domain of the transfo, to help find an inverse.

Returns

An AST Mapping that represents this transformation.

Reimplemented in lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 189 of file Gtransfo.h.

                                                                                  {
        throw std::logic_error("toAstMap is not implemented for this class.");
    }

transformErrors()

void lsst::jointcal::Gtransfo::transformErrors ( Point const &  where, const double *  vIn, double *  vOut  ) const

virtualinherited

transform errors (represented as double[3] in order V(xx),V(yy),Cov(xy))

Definition at line 157 of file Gtransfo.cc.

                                                                                        {
    GtransfoLin der;
    computeDerivative(where, der, 0.01);
    double a11 = der.A11();
    double a22 = der.A22();
    double a21 = der.A21();
    double a12 = der.A12();

    /*      (a11 a12)          (vxx  vxy)
       M =  (       )  and V = (        )
            (a21 a22)          (xvy  vyy)

       Vxx = Vin[0], vyy = Vin[1], Vxy = Vin[2];
       we want to compute M*V*tp(M)
       A lin alg light package would be perfect...
    */
    int xx = 0;
    int yy = 1;
    int xy = 2;
    // M*V :

    double b11 = a11 * vIn[xx] + a12 * vIn[xy];
    double b22 = a21 * vIn[xy] + a22 * vIn[yy];
    double b12 = a11 * vIn[xy] + a12 * vIn[yy];
    double b21 = a21 * vIn[xx] + a22 * vIn[xy];

    // (M*V) * tp(M)

    vOut[xx] = b11 * a11 + b12 * a12;
    vOut[xy] = b11 * a21 + b12 * a22;
    vOut[yy] = b21 * a21 + b22 * a22;
}

transformPosAndErrors()

void lsst::jointcal::Gtransfo::transformPosAndErrors ( const FatPoint &  in, FatPoint &  out  ) const

virtualinherited

Reimplemented in lsst::jointcal::TanRaDec2Pix, and lsst::jointcal::GtransfoPoly.

Definition at line 140 of file Gtransfo.cc.

                                                                            {
    FatPoint res;  // in case in and out are the same address...
    res = apply(in);
    GtransfoLin der;
    // could save a call here, since Derivative needs the transform of where that we already have
    // 0.01 may not be a very good idea in all cases. May be we should provide a way of altering that.
    computeDerivative(in, der, 0.01);
    double a11 = der.A11();
    double a22 = der.A22();
    double a21 = der.A21();
    double a12 = der.A12();
    res.vx = a11 * (a11 * in.vx + 2 * a12 * in.vxy) + a12 * a12 * in.vy;
    res.vy = a21 * a21 * in.vx + a22 * a22 * in.vy + 2. * a21 * a22 * in.vxy;
    res.vxy = a21 * a11 * in.vx + a22 * a12 * in.vy + (a21 * a12 + a11 * a22) * in.vxy;
    out = res;
}

transformStar()

void lsst::jointcal::Gtransfo::transformStar ( FatPoint &  in ) const

inlineinherited

allows to write MyTransfo(MyStar)

Definition at line 108 of file Gtransfo.h.

{ transformPosAndErrors(in, in); }

write() [1/2]

void lsst::jointcal::Gtransfo::write ( const std::string &  fileName ) const

inherited

Definition at line 239 of file Gtransfo.cc.

                                                    {
    ofstream s(fileName.c_str());
    write(s);
    bool ok = !s.fail();
    s.close();
    if (!ok)
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Gtransfo::write, something went wrong for file " + fileName);
}

write() [2/2]

void lsst::jointcal::Gtransfo::write ( std::ostream &  stream ) const

virtualinherited

Reimplemented in lsst::jointcal::GtransfoPoly, and lsst::jointcal::GtransfoIdentity.

Definition at line 249 of file Gtransfo.cc.

                                          {
    throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                      "Gtransfo::write(ostream), should never be called. MEans that it is missing in some "
                      "derived class ");
}

Member Data Documentation

corr

std::unique_ptr<GtransfoPoly> lsst::jointcal::BaseTanWcs::corr

protectedinherited

Definition at line 592 of file Gtransfo.h.

cos0

double lsst::jointcal::BaseTanWcs::cos0

protectedinherited

Definition at line 594 of file Gtransfo.h.

dec0

double lsst::jointcal::BaseTanWcs::dec0

protectedinherited

Definition at line 593 of file Gtransfo.h.

linPix2Tan

GtransfoLin lsst::jointcal::BaseTanWcs::linPix2Tan

protectedinherited

Definition at line 590 of file Gtransfo.h.

ra0

double lsst::jointcal::BaseTanWcs::ra0

protectedinherited

Definition at line 593 of file Gtransfo.h.

sin0

double lsst::jointcal::BaseTanWcs::sin0

protectedinherited

Definition at line 594 of file Gtransfo.h.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-24-gd8faad8+3/include/lsst/jointcal/Gtransfo.h
• /j/snowflake/release/lsstsw/stack/Linux64/jointcal/16.0-24-gd8faad8+3/src/Gtransfo.cc