LSST Applications g0b6bd0c080+a72a5dd7e6,g1182afd7b4+2a019aa3bb,g17e5ecfddb+2b8207f7de,g1d67935e3f+06cf436103,g38293774b4+ac198e9f13,g396055baef+6a2097e274,g3b44f30a73+6611e0205b,g480783c3b1+98f8679e14,g48ccf36440+89c08d0516,g4b93dc025c+98f8679e14,g5c4744a4d9+a302e8c7f0,g613e996a0d+e1c447f2e0,g6c8d09e9e7+25247a063c,g7271f0639c+98f8679e14,g7a9cd813b8+124095ede6,g9d27549199+a302e8c7f0,ga1cf026fa3+ac198e9f13,ga32aa97882+7403ac30ac,ga786bb30fb+7a139211af,gaa63f70f4e+9994eb9896,gabf319e997+ade567573c,gba47b54d5d+94dc90c3ea,gbec6a3398f+06cf436103,gc6308e37c7+07dd123edb,gc655b1545f+ade567573c,gcc9029db3c+ab229f5caf,gd01420fc67+06cf436103,gd877ba84e5+06cf436103,gdb4cecd868+6f279b5b48,ge2d134c3d5+cc4dbb2e3f,ge448b5faa6+86d1ceac1d,gecc7e12556+98f8679e14,gf3ee170dca+25247a063c,gf4ac96e456+ade567573c,gf9f5ea5b4d+ac198e9f13,gff490e6085+8c2580be5c,w.2022.27
LSST Data Management Base Package
ChebyMap.cc
Go to the documentation of this file.
1/*
2 * LSST Data Management System
3 * Copyright 2017 AURA/LSST.
4 *
5 * This product includes software developed by the
6 * LSST Project (http://www.lsst.org/).
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the LSST License Statement and
19 * the GNU General Public License along with this program. If not,
20 * see <https://www.lsstcorp.org/LegalNotices/>.
21 */
22#include <sstream>
23#include <stdexcept>
24
26#include "astshim/ChebyMap.h"
27
28namespace ast {
29
30ChebyMap ChebyMap::polyTran(bool forward, double acc, double maxacc, int maxorder,
31 std::vector<double> const &lbnd, std::vector<double> const &ubnd) const {
32 return ChebyMap(detail::polyTranImpl<AstChebyMap>(*this, forward, acc, maxacc, maxorder, lbnd, ubnd));
33}
34
35ChebyMap ChebyMap::polyTran(bool forward, double acc, double maxacc, int maxorder) const {
36 // Note: AST directly supports specifying lbnd or ubnd as NULL for ChebyMap
37 // but the code provide explicit bounds for two reasons:
38 // - This simplifies the interface to polyTranImpl.
39 // - This simplifies the interface to ChebyMap.polyTran by requiring
40 // either both boundaries or neither. Though admittedly this code
41 // could let polyTranImpl do the work instead of calling getDomain.
42 // - When this code was written, the feature of allowing NULL for lbnd or ubnd
43 // didn't work (though I expect it to be fixed very soon).
44 auto domain = getDomain(!forward);
45 return ChebyMap(detail::polyTranImpl<AstChebyMap>(*this, forward, acc, maxacc, maxorder, domain.lbnd,
46 domain.ubnd));
47}
48
49ChebyMap::ChebyMap(AstChebyMap *map) : Mapping(reinterpret_cast<AstMapping *>(map)) {
50 if (!astIsAChebyMap(getRawPtr())) {
52 os << "this is a " << getClassName() << ", which is not a ChebyMap";
53 throw std::invalid_argument(os.str());
54 }
55}
56
57ChebyDomain ChebyMap::getDomain(bool forward) const {
58 int nElements = forward ? getNIn() : getNOut();
59 std::vector<double> lbnd(nElements, 0.0);
60 std::vector<double> ubnd(nElements, 0.0);
61 astChebyDomain(getRawPtr(), static_cast<int>(forward), lbnd.data(), ubnd.data());
62 assertOK();
63 for (auto &val : lbnd) {
64 if (val == AST__BAD) {
65 throw std::runtime_error("Could not compute domain");
66 }
67 }
68 for (auto &val : ubnd) {
69 if (val == AST__BAD) {
70 throw std::runtime_error("Could not compute domain");
71 }
72 }
73 return ChebyDomain(lbnd, ubnd);
74}
75
77AstChebyMap *ChebyMap::_makeRawChebyMap(ConstArray2D const &coeff_f, ConstArray2D const &coeff_i,
78 std::vector<double> const &lbnd_f, std::vector<double> const &ubnd_f,
79 std::vector<double> const &lbnd_i, std::vector<double> const &ubnd_i,
80 std::string const &options) const {
81 const int nin = coeff_f.getSize<1>() - 2;
82 const int ncoeff_f = coeff_f.getSize<0>();
83 const int nout = coeff_i.getSize<1>() - 2;
84 const int ncoeff_i = coeff_i.getSize<0>();
85 const bool has_fwd = ncoeff_f > 0;
86 const bool has_inv = ncoeff_i > 0;
87
88 if (!has_fwd and !has_inv) {
90 "Must specify forward or inverse transform (coeff_f and coeff_i both empty)");
91 }
92 if (nin <= 0) {
94 os << "coeff_f row length = " << nin + 2
95 << ", which is too short; length = nin + 2 and nin must be > 0";
96 throw std::invalid_argument(os.str());
97 }
98 if (nout <= 0) {
100 os << "coeff_i row length " << nout + 2
101 << ", which is too short; length = nout + 2 and nout must be > 0";
102 throw std::invalid_argument(os.str());
103 }
104 if (has_fwd) {
105 detail::assertEqual(lbnd_f.size(), "lbnd_f size", static_cast<std::size_t>(nin),
106 "number of input axes");
107 detail::assertEqual(ubnd_f.size(), "ubnd_f size", static_cast<std::size_t>(nin),
108 "number of input axes");
109 }
110 if (has_inv) {
111 detail::assertEqual(lbnd_i.size(), "lbnd_i size", static_cast<std::size_t>(nout),
112 "number of output axes");
113 detail::assertEqual(ubnd_i.size(), "ubnd_i size", static_cast<std::size_t>(nout),
114 "number of output axes");
115 }
116
117 auto result = reinterpret_cast<AstChebyMap *>(astChebyMap(nin, nout, ncoeff_f, coeff_f.getData(),
118 ncoeff_i, coeff_i.getData(), lbnd_f.data(),
119 ubnd_f.data(), lbnd_i.data(), ubnd_i.data(),
120 "%s", options.c_str()));
121 assertOK();
122 return result;
123}
124
126AstChebyMap *ChebyMap::_makeRawChebyMap(ConstArray2D const &coeff_f, int nout,
127 std::vector<double> const &lbnd_f, std::vector<double> const &ubnd_f,
128 std::string const &options) const {
129 const int nin = coeff_f.getSize<1>() - 2;
130 const int ncoeff_f = coeff_f.getSize<0>();
131 const bool has_fwd = ncoeff_f > 0;
132
133 if (!has_fwd) {
134 throw std::invalid_argument("Must specify forward transform (coeff_f is empty)");
135 }
136 if (nin <= 0) {
138 os << "coeff_f row length = " << nin + 2
139 << ", which is too short; length = nin + 2 and nin must be > 0";
140 throw std::invalid_argument(os.str());
141 }
142 if (nout <= 0) {
144 os << "coeff_i row length " << nout + 2
145 << ", which is too short; length = nout + 2 and nout must be > 0";
146 throw std::invalid_argument(os.str());
147 }
148 detail::assertEqual(lbnd_f.size(), "lbnd_f size", static_cast<std::size_t>(nin), "number of input axes");
149 detail::assertEqual(ubnd_f.size(), "ubnd_f size", static_cast<std::size_t>(nin), "number of input axes");
150
151 return reinterpret_cast<AstChebyMap *>(astChebyMap(nin, nout, ncoeff_f, coeff_f.getData(), 0, nullptr,
152 lbnd_f.data(), ubnd_f.data(), nullptr, nullptr, "%s",
153 options.c_str()));
154}
155
156} // namespace ast
py::object result
Definition: _schema.cc:429
std::ostream * os
Definition: Schema.cc:557
T c_str(T... args)
The domain over which a Chebyshev polynomial is defined; returned by ChebyMap.getDomain.
Definition: ChebyMap.h:37
A ChebyMap is a form of Mapping which performs a Chebyshev polynomial transformation.
Definition: ChebyMap.h:97
ChebyMap(ConstArray2D const &coeff_f, ConstArray2D const &coeff_i, std::vector< double > const &lbnd_f, std::vector< double > const &ubnd_f, std::vector< double > const &lbnd_i, std::vector< double > const &ubnd_i, std::string const &options="")
Construct a ChebyMap with a specified forward and/or inverse transforms.
Definition: ChebyMap.h:161
ChebyDomain getDomain(bool forward) const
Return the bounding box of the domain of a ChebyMap.
Definition: ChebyMap.cc:57
ChebyMap polyTran(bool forward, double acc, double maxacc, int maxorder, std::vector< double > const &lbnd, std::vector< double > const &ubnd) const
This function creates a new ChebyMap which is a copy of this one, in which a specified transformation...
Definition: ChebyMap.cc:30
An abstract base class for objects which transform one set of coordinates to another.
Definition: Mapping.h:59
int getNOut() const
Get NOut: the number of output axes.
Definition: Mapping.h:82
int getNIn() const
Get NIn: the number of input axes.
Definition: Mapping.h:77
std::string getClassName() const
Get Class: the name of the class (e.g.
Definition: Object.h:139
AstObject const * getRawPtr() const
Get the raw AST pointer.
Definition: Object.h:292
T data(T... args)
void assertEqual(T1 val1, std::string const &descr1, T2 val2, std::string const &descr2)
Definition: utils.h:48
template AstChebyMap * polyTranImpl< AstChebyMap >(ChebyMap const &, bool, double, double, int, std::vector< double > const &, std::vector< double > const &)
AST wrapper classes and functions.
void assertOK(AstObject *rawPtr1=nullptr, AstObject *rawPtr2=nullptr)
Throw std::runtime_error if AST's state is bad.
Definition: base.cc:49
ndarray::Array< const double, 2, 2 > ConstArray2D
2D array of const double; typically used for lists of const points
Definition: base.h:46
T size(T... args)
ImageT val
Definition: CR.cc:146