LSSTApplications  17.0+11,17.0+34,17.0+56,17.0+57,17.0+59,17.0+7,17.0-1-g377950a+33,17.0.1-1-g114240f+2,17.0.1-1-g4d4fbc4+28,17.0.1-1-g55520dc+49,17.0.1-1-g5f4ed7e+52,17.0.1-1-g6dd7d69+17,17.0.1-1-g8de6c91+11,17.0.1-1-gb9095d2+7,17.0.1-1-ge9fec5e+5,17.0.1-1-gf4e0155+55,17.0.1-1-gfc65f5f+50,17.0.1-1-gfc6fb1f+20,17.0.1-10-g87f9f3f+1,17.0.1-11-ge9de802+16,17.0.1-16-ga14f7d5c+4,17.0.1-17-gc79d625+1,17.0.1-17-gdae4c4a+8,17.0.1-2-g26618f5+29,17.0.1-2-g54f2ebc+9,17.0.1-2-gf403422+1,17.0.1-20-g2ca2f74+6,17.0.1-23-gf3eadeb7+1,17.0.1-3-g7e86b59+39,17.0.1-3-gb5ca14a,17.0.1-3-gd08d533+40,17.0.1-30-g596af8797,17.0.1-4-g59d126d+4,17.0.1-4-gc69c472+5,17.0.1-6-g5afd9b9+4,17.0.1-7-g35889ee+1,17.0.1-7-gc7c8782+18,17.0.1-9-gc4bbfb2+3,w.2019.22
LSSTDataManagementBasePackage
Public Member Functions | Public Attributes | List of all members
ast::QuadApprox Class Reference

A quadratic approximation to a 2D Mapping. More...

#include <QuadApprox.h>

Public Member Functions

 QuadApprox (Mapping const &map, std::vector< double > const &lbnd, std::vector< double > const &ubnd, int nx=3, int ny=3)
 Obtain a quadratic approximation to a 2D Mapping. More...
 
 QuadApprox (QuadApprox const &)=default
 
 QuadApprox (QuadApprox &&)=default
 
QuadApproxoperator= (QuadApprox const &)=default
 
QuadApproxoperator= (QuadApprox &&)=default
 

Public Attributes

std::vector< double > fit
 A vector of coefficients of the quadratic approximation to the specified transformation. More...
 
double rms
 The RMS residual between the fit and the Mapping, summed over all Mapping outputs. More...
 

Detailed Description

A quadratic approximation to a 2D Mapping.

Construct the class to compute the contained fields:

Definition at line 36 of file QuadApprox.h.

Constructor & Destructor Documentation

◆ QuadApprox() [1/3]

ast::QuadApprox::QuadApprox ( Mapping const &  map,
std::vector< double > const &  lbnd,
std::vector< double > const &  ubnd,
int  nx = 3,
int  ny = 3 
)
explicit

Obtain a quadratic approximation to a 2D Mapping.

Compute the coefficients of a quadratic fit to the supplied Mapping over the input area specified by lbnd and ubnd. The Mapping must have 2 inputs, but may have any number of outputs. The i'th Mapping output is modeled as a quadratic function of the 2 inputs (x,y):

output_i = a_i_0 + a_i_1*x + a_i_2*y + a_i_3*x*y + a_i_4*x*x + a_i_5*y*y

The fit vector is set tothe values of the co-efficients a_0_0, a_0_1, etc.

Parameters
[in]mapMapping to fit.
[in]lbndThe lower bounds of a box defined within the input coordinate system of the Mapping. The number of elements in this vector should equal map.getNIn(). This box should specify the region over which the fit is to be performed.
[in]ubndThe upper bounds of the box specifying the region over which the fit is to be performed.
[in]nxThe number of points to place along the first Mapping input. The first point is at lbnd[0] and the last is at ubnd[0]". If a value less than three is supplied a value of three will be used.
[in]nyThe number of points to place along the second Mapping input. The first point is at lbnd[1] and the last is at ubnd[1]. If a value less than three is supplied a value of three will be used.
Exceptions
std::invalid_argumentif the mapping does not have 2 inputs, or if lbnd or ubnd do not each contain 2 elements.
std::runtime_errorif the fit cannot be computed.

Definition at line 31 of file QuadApprox.cc.

33  : fit(6 * map.getNOut()), rms(0) {
34  int const nIn = map.getNIn();
35  detail::assertEqual(nIn, "map.getNIn()", 2, "required nIn");
36  detail::assertEqual(lbnd.size(), "lbnd.size", static_cast<std::size_t>(nIn), "nIn");
37  detail::assertEqual(ubnd.size(), "ubnd.size", static_cast<std::size_t>(nIn), "nIn");
38  fit.reserve(6 * map.getNOut());
39  bool isok = astQuadApprox(map.getRawPtr(), lbnd.data(), ubnd.data(), nx, ny, fit.data(), &rms);
40  assertOK();
41  if (!isok) {
42  throw std::runtime_error("Failed to fit a quadratic approximation");
43  }
44 }
void assertOK(AstObject *rawPtr1=nullptr, AstObject *rawPtr2=nullptr)
Throw std::runtime_error if AST&#39;s state is bad.
Definition: base.cc:49
std::vector< double > fit
A vector of coefficients of the quadratic approximation to the specified transformation.
Definition: QuadApprox.h:98
T data(T... args)
T size(T... args)
double rms
The RMS residual between the fit and the Mapping, summed over all Mapping outputs.
Definition: QuadApprox.h:102
void assertEqual(T1 val1, std::string const &descr1, T2 val2, std::string const &descr2)
Definition: utils.h:48
T reserve(T... args)

◆ QuadApprox() [2/3]

ast::QuadApprox::QuadApprox ( QuadApprox const &  )
default

◆ QuadApprox() [3/3]

ast::QuadApprox::QuadApprox ( QuadApprox &&  )
default

Member Function Documentation

◆ operator=() [1/2]

QuadApprox& ast::QuadApprox::operator= ( QuadApprox const &  )
default

◆ operator=() [2/2]

QuadApprox& ast::QuadApprox::operator= ( QuadApprox &&  )
default

Member Data Documentation

◆ fit

std::vector<double> ast::QuadApprox::fit

A vector of coefficients of the quadratic approximation to the specified transformation.

This vector will contain "6*NOut", elements: the first 6 elements hold the fit to the first Mapping output, the next 6 elements hold the fit to the second Mapping output, etc. So if the Mapping has 2 inputs and 2 outputs the quadratic approximation to the forward transformation is:

X_out = fit[0] + fit[1]*X_in + fit[2]*Y_in + fit[3]*X_in*Y_in +
        fit[4]*X_in*X_in + fit[5]*Y_in*Y_in
Y_out = fit[6] + fit[7]*X_in + fit[8]*Y_in + fit[9]*X_in*Y_in +
        fit[10]*X_in*X_in + fit[11]*Y_in*Y_in
X_out = fit(1) + fit(2)*X_in + fit(3)*Y_in + fit(4)*X_in*Y_in +
        fit(5)*X_in*X_in + fit(6)*Y_in*Y_in
Y_out = fit(7) + fit(8)*X_in + fit(9)*Y_in + fit(10)*X_in*Y_in +
        fit(11)*X_in*X_in + fit(12)*Y_in*Y_in

Definition at line 98 of file QuadApprox.h.

◆ rms

double ast::QuadApprox::rms

The RMS residual between the fit and the Mapping, summed over all Mapping outputs.

Definition at line 102 of file QuadApprox.h.


The documentation for this class was generated from the following files: