lsst.jointcal g65d8d5e0e2+5c163bb44e
ChipVisitAstrometryMapping.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/pex/exceptions.h"
27
29
30namespace lsst {
31namespace jointcal {
32
35 : _m1(chipMapping), _m2(visitMapping) {
36 /* Allocate the record of temporary variables, so that they are not
37 allocated at every call. This is hidden behind a pointer in order
38 to be allowed to alter them in a const routine. */
39 tmp = std::unique_ptr<tmpVars>(new tmpVars);
40 setWhatToFit(true, true);
41}
42
43std::size_t ChipVisitAstrometryMapping::getNpar() const { return _nPar1 + _nPar2; }
44
46 std::size_t npar = getNpar();
47 if (indices.size() < npar) indices.resize(npar);
48 // in case we are only fitting one of the two transforms
49 if (_nPar1)
50 _m1->getMappingIndices(indices);
51 else if (_nPar2) {
52 _m2->getMappingIndices(indices);
53 return;
54 }
55 // if we get here we are fitting both
56 // there is probably a more elegant way to feed a subpart of a std::vector
57 IndexVector ind2(_nPar2);
58 _m2->getMappingIndices(ind2);
59 for (Eigen::Index k = 0; k < _nPar2; ++k) indices.at(k + _nPar1) = ind2.at(k);
60}
61
63 Eigen::MatrixX2d &H) const {
64 // not true in general. Will crash if H is too small.
65 // assert(H.cols()==Npar());
66
67 FatPoint pMid;
68 // don't need errors there but no Mapping::Transform() routine.
69
70 if (_nPar1) {
71 _m1->computeTransformAndDerivatives(where, pMid, tmp->h1);
72 // the last argument is epsilon and is not used for polynomials
73 _m2->positionDerivative(pMid, tmp->dt2dx, 1e-4);
74 H.block(0, 0, _nPar1, 2) = tmp->h1 * tmp->dt2dx;
75 } else
76 _m1->transformPosAndErrors(where, pMid);
77 if (_nPar2) {
78 _m2->computeTransformAndDerivatives(pMid, outPoint, tmp->h2);
79 H.block(_nPar1, 0, _nPar2, 2) = tmp->h2;
80 } else
81 _m2->transformPosAndErrors(pMid, outPoint);
82}
83
88void ChipVisitAstrometryMapping::setWhatToFit(const bool fittingT1, const bool fittingT2) {
89 if (fittingT1) {
90 _nPar1 = _m1->getNpar();
91 tmp->h1 = Eigen::MatrixX2d(_nPar1, 2);
92 } else
93 _nPar1 = 0;
94 if (fittingT2) {
95 _nPar2 = _m2->getNpar();
96 tmp->h2 = Eigen::MatrixX2d(_nPar2, 2);
97 } else
98 _nPar2 = 0;
99}
100
102 FatPoint pMid;
103 _m1->transformPosAndErrors(where, pMid);
104 _m2->transformPosAndErrors(pMid, outPoint);
105}
106
107void ChipVisitAstrometryMapping::positionDerivative(Point const &where, Eigen::Matrix2d &derivative,
108 double epsilon) const {
109 Eigen::Matrix2d d1, d2; // seems that it does not trigger dynamic allocation
110 _m1->positionDerivative(where, d1, 1e-4);
111 FatPoint pMid;
112 _m1->transformPosAndErrors(where, pMid);
113 _m2->positionDerivative(pMid, d2, 1e-4);
114 /* The following line is not a mistake. It is a consequence
115 of chosing derivative(0,1) = d(y_out)/d x_in. */
116 derivative = d1 * d2;
117}
118
121 " The routine ChipVisitAstrometryMapping::freezeErrorTransform() was thought to be "
122 "useless and is not implemented (yet)");
123}
124
126 out << "Composed Astrometry Mapping:" << std::endl;
127 out << "Sensor f(x,y)->(u,v): " << *_m1 << std::endl;
128 out << "Visit f(u,v)->alpha,delta: " << *_m2 << std::endl;
129}
130
131} // namespace jointcal
132} // namespace lsst
Eigen::Matrix< double, Eigen::Dynamic, 2 > MatrixX2d
Definition: Eigenstuff.h:33
#define LSST_EXCEPT(type,...)
T at(T... args)
std::size_t getNpar() const override
Number of parameters in total.
void getMappingIndices(IndexVector &indices) const override
Sets how this set of parameters (of length Npar()) map into the "grand" fit Expects that indices has ...
void freezeErrorTransform()
Currently not implemented.
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 positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const override
The derivative w.r.t. position.
void print(std::ostream &out) const override
Print a string representation of the contents of this mapping, for debugging.
ChipVisitAstrometryMapping(std::shared_ptr< SimpleAstrometryMapping > chipMapping, std::shared_ptr< SimpleAstrometryMapping > visitMapping)
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const override
The same as above but without the parameter derivatives (used to evaluate chi^2)
A Point with uncertainties.
Definition: FatPoint.h:34
A point in a plane.
Definition: Point.h:37
T endl(T... args)
Class for a simple mapping implementing a generic AstrometryTransform.
T resize(T... args)
T size(T... args)