lsst.jointcal g65d8d5e0e2+22fee61c23
SimpleAstrometryMapping.cc
Go to the documentation of this file.
1// -*- LSST-C++ -*-
2/*
3 * This file is part of jointcal.
4 *
5 * Developed for the LSST Data Management System.
6 * This product includes software developed by the LSST Project
7 * (https://www.lsst.org).
8 * See the COPYRIGHT file at the top-level directory of this distribution
9 * for details of code ownership.
10 *
11 * This program is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation, either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program. If not, see <https://www.gnu.org/licenses/>.
23 */
24
28
29namespace lsst {
30namespace jointcal {
31
33 if (indices.size() < getNpar()) {
34 indices.resize(getNpar());
35 }
36 for (std::size_t k = 0; k < getNpar(); ++k) {
37 indices[k] = index + k;
38 }
39}
40
42 transform->transformPosAndErrors(where, outPoint);
43 FatPoint tmp;
44 errorProp->transformPosAndErrors(where, tmp);
45 outPoint.vx = tmp.vx;
46 outPoint.vy = tmp.vy;
47 outPoint.vxy = tmp.vxy;
48}
49
50void SimpleAstrometryMapping::positionDerivative(Point const &where, Eigen::Matrix2d &derivative,
51 double epsilon) const {
52 errorProp->computeDerivative(where, *lin, epsilon);
53 derivative(0, 0) = lin->getCoefficient(1, 0, 0);
54 //
55 /* This does not work : it was proved by rotating the frame
56 see the compilation switch ROTATE_T2 in constrainedAstrometryModel.cc
57 derivative(1,0) = lin->getCoefficient(1,0,1);
58 derivative(0,1) = lin->getCoefficient(0,1,0);
59 */
60 derivative(1, 0) = lin->getCoefficient(0, 1, 0);
61 derivative(0, 1) = lin->getCoefficient(1, 0, 1);
62 derivative(1, 1) = lin->getCoefficient(0, 1, 1);
63}
64
66 Eigen::MatrixX2d &H) const {
67 transformPosAndErrors(where, outPoint);
68 transform->paramDerivatives(where, &H(0, 0), &H(0, 1));
69}
70
72
74 AstrometryTransformPolynomial const &transform)
75 : SimpleAstrometryMapping(transform), _centerAndScale(CenterAndScale) {
76 // We assume that the initialization was done properly, for example that
77 // transform = pixToTangentPlane*CenterAndScale.inverted(), so we do not touch transform.
78 /* store the (spatial) derivative of _centerAndScale. For the extra
79 diagonal terms, just copied the ones in positionDerivatives */
80 preDer(0, 0) = _centerAndScale.getCoefficient(1, 0, 0);
81 preDer(1, 0) = _centerAndScale.getCoefficient(0, 1, 0);
82 preDer(0, 1) = _centerAndScale.getCoefficient(1, 0, 1);
83 preDer(1, 1) = _centerAndScale.getCoefficient(0, 1, 1);
84
85 // check of matrix indexing (once for all)
86 MatrixX2d H(3, 2);
87 assert((&H(1, 0) - &H(0, 0)) == 1);
88}
89
90void SimplePolyMapping::positionDerivative(Point const &where, Eigen::Matrix2d &derivative,
91 double epsilon) const {
92 Point tmp = _centerAndScale.apply(where);
93 errorProp->computeDerivative(tmp, *lin, epsilon);
94 derivative(0, 0) = lin->getCoefficient(1, 0, 0);
95 //
96 /* This does not work : it was proved by rotating the frame
97 see the compilation switch ROTATE_T2 in constrainedAstrometryModel.cc
98 derivative(1,0) = lin->getCoefficient(1,0,1);
99 derivative(0,1) = lin->getCoefficient(0,1,0);
100 */
101 derivative(1, 0) = lin->getCoefficient(0, 1, 0);
102 derivative(0, 1) = lin->getCoefficient(1, 0, 1);
103 derivative(1, 1) = lin->getCoefficient(0, 1, 1);
104 derivative = preDer * derivative;
105}
106
108 Eigen::MatrixX2d &H) const {
109 FatPoint mid;
110 _centerAndScale.transformPosAndErrors(where, mid);
111 transform->transformPosAndErrors(mid, outPoint);
112 FatPoint tmp;
113 errorProp->transformPosAndErrors(mid, tmp);
114 outPoint.vx = tmp.vx;
115 outPoint.vy = tmp.vy;
116 outPoint.vxy = tmp.vxy;
117 transform->paramDerivatives(mid, &H(0, 0), &H(0, 1));
118}
119
120void SimplePolyMapping::transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const {
121 FatPoint mid;
122 _centerAndScale.transformPosAndErrors(where, mid);
123 transform->transformPosAndErrors(mid, outPoint);
124 FatPoint tmp;
125 errorProp->transformPosAndErrors(mid, tmp);
126 outPoint.vx = tmp.vx;
127 outPoint.vy = tmp.vy;
128 outPoint.vxy = tmp.vxy;
129}
130
132 // Cannot fail given the contructor:
133 const AstrometryTransformPolynomial *fittedPoly =
134 dynamic_cast<const AstrometryTransformPolynomial *>(&(*transform));
135 actualResult = (*fittedPoly) * _centerAndScale;
136 return actualResult;
137}
138
139} // namespace jointcal
140} // namespace lsst
Eigen::Matrix< double, Eigen::Dynamic, 2 > MatrixX2d
Definition: Eigenstuff.h:33
table::Key< int > transform
a virtual (interface) class for geometric transformations.
implements the linear transformations (6 real coefficients).
void apply(const double xIn, const double yIn, double &xOut, double &yOut) const override
double getCoefficient(std::size_t powX, std::size_t powY, std::size_t whichCoord) const
Get the coefficient of a given power in x and y, for either the x or y coordinate.
virtual void transformPosAndErrors(const FatPoint &in, FatPoint &out) const override
a mix of apply and Derivative
A Point with uncertainties.
Definition: FatPoint.h:34
A point in a plane.
Definition: Point.h:37
std::shared_ptr< AstrometryTransform > errorProp
virtual void computeTransformAndDerivatives(FatPoint const &where, FatPoint &outPoint, Eigen::MatrixX2d &H) const override
Actually applies the AstrometryMapping and evaluates the derivatives w.r.t the fitted parameters.
void print(std::ostream &out) const override
Print a string representation of the contents of this mapping, for debugging.
std::size_t getNpar() const override
Number of parameters in total.
std::shared_ptr< AstrometryTransform > transform
void getMappingIndices(IndexVector &indices) const override
Sets how this set of parameters (of length Npar()) map into the "grand" fit Expects that indices has ...
std::unique_ptr< AstrometryTransformLinear > lin
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const override
The same as above but without the parameter derivatives (used to evaluate chi^2)
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const override
The derivative w.r.t. position.
void computeTransformAndDerivatives(FatPoint const &where, FatPoint &outPoint, Eigen::MatrixX2d &H) const override
Calls the transforms and implements the centering and scaling of coordinates.
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const override
The derivative w.r.t. position.
SimplePolyMapping(AstrometryTransformLinear const &CenterAndScale, AstrometryTransformPolynomial const &transform)
The transformation will be initialized to transform, so that the effective transformation reads trans...
AstrometryTransform const & getTransform() const override
Access to the (fitted) transform.
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const override
The same as above but without the parameter derivatives (used to evaluate chi^2)
Class for a simple mapping implementing a generic AstrometryTransform.
T resize(T... args)
T size(T... args)