LSSTApplications  20.0.0
LSSTDataManagementBasePackage
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 
26 #include "lsst/jointcal/FatPoint.h"
28 
29 namespace lsst {
30 namespace 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 
50 void 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 
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 
90 void 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 
120 void 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
std::vector::resize
T resize(T... args)
lsst::jointcal::FatPoint::vxy
double vxy
Definition: FatPoint.h:36
lsst::jointcal::SimpleAstrometryMapping::positionDerivative
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const override
The derivative w.r.t. position.
Definition: SimpleAstrometryMapping.cc:50
Eigenstuff.h
lsst::jointcal::AstrometryTransformLinear
implements the linear transformations (6 real coefficients).
Definition: AstrometryTransform.h:426
std::vector
STL class.
std::vector::size
T size(T... args)
lsst::jointcal::SimpleAstrometryMapping::index
Eigen::Index index
Definition: SimpleAstrometryMapping.h:105
lsst::jointcal::SimpleAstrometryMapping::transform
std::shared_ptr< AstrometryTransform > transform
Definition: SimpleAstrometryMapping.h:108
lsst::jointcal::AstrometryTransformPolynomial::transformPosAndErrors
virtual void transformPosAndErrors(const FatPoint &in, FatPoint &out) const override
a mix of apply and Derivative
Definition: AstrometryTransform.cc:656
MatrixX2d
Eigen::Matrix< double, Eigen::Dynamic, 2 > MatrixX2d
Definition: Eigenstuff.h:33
FatPoint.h
lsst::jointcal::SimplePolyMapping::positionDerivative
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const override
The derivative w.r.t. position.
Definition: SimpleAstrometryMapping.cc:90
lsst::jointcal::SimpleAstrometryMapping
Definition: SimpleAstrometryMapping.h:41
std::ostream
STL class.
lsst::jointcal::SimplePolyMapping::transformPosAndErrors
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const override
The same as above but without the parameter derivatives (used to evaluate chi^2)
Definition: SimpleAstrometryMapping.cc:120
lsst::jointcal::SimplePolyMapping::getTransform
AstrometryTransform const & getTransform() const override
Access to the (fitted) transform.
Definition: SimpleAstrometryMapping.cc:131
lsst::jointcal::SimplePolyMapping::SimplePolyMapping
SimplePolyMapping(AstrometryTransformLinear const &CenterAndScale, AstrometryTransformPolynomial const &transform)
The transformation will be initialized to transform, so that the effective transformation reads trans...
Definition: SimpleAstrometryMapping.cc:73
lsst::jointcal::SimpleAstrometryMapping::lin
std::unique_ptr< AstrometryTransformLinear > lin
Definition: SimpleAstrometryMapping.h:113
lsst::jointcal
Definition: Associations.h:49
lsst::jointcal::FatPoint
A Point with uncertainties.
Definition: FatPoint.h:34
lsst::jointcal::SimpleAstrometryMapping::print
void print(std::ostream &out) const override
Print a string representation of the contents of this mapping, for debugging.
Definition: SimpleAstrometryMapping.cc:71
lsst::jointcal::SimpleAstrometryMapping::getMappingIndices
void getMappingIndices(IndexVector &indices) const override
Sets how this set of parameters (of length Npar()) map into the "grand" fit Expects that indices has ...
Definition: SimpleAstrometryMapping.cc:32
lsst::jointcal::AstrometryTransformPolynomial::getCoefficient
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.
Definition: AstrometryTransform.cc:740
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
lsst::jointcal::FatPoint::vx
double vx
Definition: FatPoint.h:36
lsst::jointcal::SimplePolyMapping::computeTransformAndDerivatives
void computeTransformAndDerivatives(FatPoint const &where, FatPoint &outPoint, Eigen::MatrixX2d &H) const override
Calls the transforms and implements the centering and scaling of coordinates.
Definition: SimpleAstrometryMapping.cc:107
lsst::jointcal::SimpleAstrometryMapping::computeTransformAndDerivatives
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.
Definition: SimpleAstrometryMapping.cc:65
lsst::jointcal::FatPoint::vy
double vy
Definition: FatPoint.h:36
lsst::jointcal::Point
A point in a plane.
Definition: Point.h:36
transform
table::Key< int > transform
Definition: TransformMap.cc:299
lsst::jointcal::AstrometryTransformPolynomial
Polynomial transformation class.
Definition: AstrometryTransform.h:280
std::size_t
lsst::jointcal::AstrometryTransform
a virtual (interface) class for geometric transformations.
Definition: AstrometryTransform.h:65
lsst::jointcal::SimpleAstrometryMapping::errorProp
std::shared_ptr< AstrometryTransform > errorProp
Definition: SimpleAstrometryMapping.h:110
lsst::jointcal::SimpleAstrometryMapping::getNpar
std::size_t getNpar() const override
Number of parameters in total.
Definition: SimpleAstrometryMapping.h:61
lsst::jointcal::SimpleAstrometryMapping::transformPosAndErrors
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const override
The same as above but without the parameter derivatives (used to evaluate chi^2)
Definition: SimpleAstrometryMapping.cc:41
lsst::jointcal::AstrometryTransformLinear::apply
void apply(const double xIn, const double yIn, double &xOut, double &yOut) const override
Definition: AstrometryTransform.cc:572
SimpleAstrometryMapping.h