2 #ifndef LSST_JOINTCAL_SIMPLE_POLY_MAPPING_H 3 #define LSST_JOINTCAL_SIMPLE_POLY_MAPPING_H 30 std::unique_ptr<GtransfoLin>
lin;
34 : toFit(toFit), transfo(gtransfo.clone()), errorProp(transfo), lin(new
GtransfoLin) {
49 errorProp = transfo->clone();
57 return transfo->getNpar();
65 for (
unsigned k = 0; k <
getNpar(); ++k) indices[k] = index + k;
70 transfo->transformPosAndErrors(where, outPoint);
72 errorProp->transformPosAndErrors(where, tmp);
80 errorProp->computeDerivative(where, *lin, epsilon);
81 derivative(0, 0) = lin->coeff(1, 0, 0);
88 derivative(1, 0) = lin->coeff(0, 1, 0);
89 derivative(0, 1) = lin->coeff(1, 0, 1);
90 derivative(1, 1) = lin->coeff(0, 1, 1);
94 void offsetParams(
double const *delta) { transfo->offsetParams(delta); }
105 transfo->paramDerivatives(where, &H(0, 0), &H(0, 1));
118 Eigen::Matrix2d preDer;
135 preDer(0, 0) = _centerAndScale.
coeff(1, 0, 0);
136 preDer(1, 0) = _centerAndScale.
coeff(0, 1, 0);
137 preDer(0, 1) = _centerAndScale.
coeff(1, 0, 1);
138 preDer(1, 1) = _centerAndScale.
coeff(0, 1, 1);
142 assert((&H(1, 0) - &H(0, 0)) == 1);
157 derivative(0, 0) =
lin->coeff(1, 0, 0);
164 derivative(1, 0) =
lin->coeff(0, 1, 0);
165 derivative(0, 1) =
lin->coeff(1, 0, 1);
166 derivative(1, 1) =
lin->coeff(0, 1, 1);
167 derivative = preDer * derivative;
178 transfo->transformPosAndErrors(mid, outPoint);
180 errorProp->transformPosAndErrors(mid, tmp);
181 outPoint.
vx = tmp.
vx;
182 outPoint.
vy = tmp.
vy;
184 transfo->paramDerivatives(mid, &H(0, 0), &H(0, 1));
191 transfo->transformPosAndErrors(mid, outPoint);
193 errorProp->transformPosAndErrors(mid, tmp);
194 outPoint.
vx = tmp.
vx;
195 outPoint.
vy = tmp.
vy;
203 actualResult = (*fittedPoly) * _centerAndScale;
223 #endif // LSST_JOINTCAL_SIMPLE_POLY_MAPPING_H virtual void freezeErrorScales()
implements the linear transformations (6 real coefficients).
void apply(const double xIn, const double yIn, double &xOut, double &yOut) const
virtual class needed in the abstraction of the distortion model
SimpleGtransfoMapping & operator=(SimpleGtransfoMapping const &)=delete
Mapping implementation for a polynomial transformation.
virtual Gtransfo const & getTransfo() const
Access to the (fitted) transfo.
SimplePolyMapping(GtransfoLin const &CenterAndScale, GtransfoPoly const >ransfo)
The transformation will be initialized to gtransfo, so that the effective transformation reads gtrans...
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const
The derivative w.r.t. position.
Polynomial transformation class.
A Point with uncertainties.
void offsetParams(double const *delta)
Remember the error scale and freeze it.
unsigned getNpar() const
Number of parameters in total.
Class for a simple mapping implementing a generic Gtransfo.
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const
Implements as well the centering and scaling of coordinates.
SimpleGtransfoMapping(Gtransfo const >ransfo, bool toFit=true)
void setIndex(unsigned i)
virtual void computeTransformAndDerivatives(FatPoint const &where, FatPoint &outPoint, Eigen::MatrixX2d &H) const
Actually applies the mapping and evaluates the derivatives w.r.t the fitted parameters.
Eigen::Matrix< double, Eigen::Dynamic, 2 > MatrixX2d
virtual void transformPosAndErrors(const FatPoint &in, FatPoint &out) const
a mix of apply and Derivative
unsigned getIndex() const
position of the parameters within the grand fitting scheme
virtual void computeTransformAndDerivatives(FatPoint const &where, FatPoint &outPoint, Eigen::MatrixX2d &H) const
Calls the transforms and implements the centering and scaling of coordinates.
a virtual (interface) class for geometric transformations.
Gtransfo const & getTransfo() const
Access to the (fitted) transfo.
void positionDerivative(Point const &where, Eigen::Matrix2d &derivative, double epsilon) const
The derivative w.r.t. position.
double coeff(const unsigned powX, const unsigned powY, const unsigned whichCoord) const
access to coefficients (read only)
void setMappingIndices(std::vector< unsigned > &indices) const
Sets how this set of parameters (of length Npar()) map into the "grand" fit Expects that indices has ...
void transformPosAndErrors(FatPoint const &where, FatPoint &outPoint) const
The same as above but without the parameter derivatives (used to evaluate chi^2)
std::unique_ptr< GtransfoLin > lin
std::shared_ptr< Gtransfo > errorProp
std::shared_ptr< Gtransfo > transfo