lsst.jointcal  22.0.1-21-gbbdf43d+2c99abf513
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 
30 namespace lsst {
31 namespace 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 
43 std::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 
88 void 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 
107 void 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)