LSSTApplications  20.0.0
LSSTDataManagementBasePackage
kernelSolution.cc
Go to the documentation of this file.
1 /*
2  * LSST Data Management System
3  *
4  * This product includes software developed by the
5  * LSST Project (http://www.lsst.org/).
6  * See the COPYRIGHT file
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 "pybind11/pybind11.h"
23 #include "pybind11/eigen.h"
24 
25 #include <memory>
26 
27 #include "Eigen/Core"
28 #include "ndarray/pybind11.h"
29 
32 
33 namespace py = pybind11;
34 using namespace pybind11::literals;
35 
36 namespace lsst {
37 namespace ip {
38 namespace diffim {
39 
40 namespace {
41 
45 void declareKernelSolution(py::module &mod) {
46  py::class_<KernelSolution, std::shared_ptr<KernelSolution>> cls(mod, "KernelSolution");
47 
48  cls.def(py::init<Eigen::MatrixXd, Eigen::VectorXd, bool>(), "mMat"_a, "bVec"_a, "fitForBackground"_a);
49  cls.def(py::init<bool>(), "fitForBackground"_a);
50  cls.def(py::init<>());
51 
52  py::enum_<KernelSolution::KernelSolvedBy>(cls, "KernelSolvedBy")
53  .value("NONE", KernelSolution::KernelSolvedBy::NONE)
54  .value("CHOLESKY_LDLT", KernelSolution::KernelSolvedBy::CHOLESKY_LDLT)
55  .value("CHOLESKY_LLT", KernelSolution::KernelSolvedBy::CHOLESKY_LLT)
56  .value("LU", KernelSolution::KernelSolvedBy::LU)
57  .value("EIGENVECTOR", KernelSolution::KernelSolvedBy::EIGENVECTOR)
58  .export_values();
59 
60  py::enum_<KernelSolution::ConditionNumberType>(cls, "ConditionNumberType")
61  .value("EIGENVALUE", KernelSolution::ConditionNumberType::EIGENVALUE)
62  .value("SVD", KernelSolution::ConditionNumberType::SVD)
63  .export_values();
64 
65  cls.def("solve", (void (KernelSolution::*)()) & KernelSolution::solve);
66  cls.def("solve", (void (KernelSolution::*)(Eigen::MatrixXd const &, Eigen::VectorXd const &)) &
67  KernelSolution::solve,
68  "mMat"_a, "bVec"_a);
69  cls.def("getSolvedBy", &KernelSolution::getSolvedBy);
70  cls.def("getConditionNumber", (double (KernelSolution::*)(KernelSolution::ConditionNumberType)) &
71  KernelSolution::getConditionNumber,
72  "conditionType"_a);
73  cls.def("getConditionNumber",
74  (double (KernelSolution::*)(Eigen::MatrixXd const &, KernelSolution::ConditionNumberType)) &
75  KernelSolution::getConditionNumber,
76  "mMat"_a, "conditionType"_a);
77  cls.def("getM", &KernelSolution::getM, py::return_value_policy::copy);
78  cls.def("getB", &KernelSolution::getB, py::return_value_policy::copy);
79  cls.def("printM", &KernelSolution::printM);
80  cls.def("printB", &KernelSolution::printB);
81  cls.def("printA", &KernelSolution::printA);
82  cls.def("getId", &KernelSolution::getId);
83 }
84 
92 template <typename InputT>
93 void declareStaticKernelSolution(py::module &mod, std::string const &suffix) {
94  py::class_<StaticKernelSolution<InputT>, std::shared_ptr<StaticKernelSolution<InputT>>, KernelSolution>
95  cls(mod, ("StaticKernelSolution" + suffix).c_str());
96 
97  cls.def(py::init<lsst::afw::math::KernelList const &, bool>(), "basisList"_a, "fitForBackground"_a);
98 
99  cls.def("solve", (void (StaticKernelSolution<InputT>::*)()) & StaticKernelSolution<InputT>::solve);
100  cls.def("build", &StaticKernelSolution<InputT>::build, "templateImage"_a, "scienceImage"_a,
101  "varianceEstimate"_a);
102  cls.def("getKernel", &StaticKernelSolution<InputT>::getKernel);
103  cls.def("makeKernelImage", &StaticKernelSolution<InputT>::makeKernelImage);
104  cls.def("getBackground", &StaticKernelSolution<InputT>::getBackground);
105  cls.def("getKsum", &StaticKernelSolution<InputT>::getKsum);
106  cls.def("getSolutionPair", &StaticKernelSolution<InputT>::getSolutionPair);
107 }
108 
116 template <typename InputT>
117 void declareMaskedKernelSolution(py::module &mod, std::string const &suffix) {
118  py::class_<MaskedKernelSolution<InputT>, std::shared_ptr<MaskedKernelSolution<InputT>>,
119  StaticKernelSolution<InputT>>
120  cls(mod, ("MaskedKernelSolution" + suffix).c_str());
121 
122  cls.def(py::init<lsst::afw::math::KernelList const &, bool>(), "basisList"_a, "fitForBackground"_a);
123 
124  cls.def("buildOrig", &MaskedKernelSolution<InputT>::buildOrig, "templateImage"_a, "scienceImage"_a,
125  "varianceEstimate"_a, "pixelMask"_a);
126  cls.def("buildWithMask", &MaskedKernelSolution<InputT>::buildWithMask, "templateImage"_a,
127  "scienceImage"_a, "varianceEstimate"_a, "pixelMask"_a);
128  cls.def("buildSingleMaskOrig", &MaskedKernelSolution<InputT>::buildSingleMaskOrig, "templateImage"_a,
129  "scienceImage"_a, "varianceEstimate"_a, "maskBox"_a);
130 }
131 
139 template <typename InputT>
140 void declareRegularizedKernelSolution(py::module &mod, std::string const &suffix) {
141  py::class_<RegularizedKernelSolution<InputT>, std::shared_ptr<RegularizedKernelSolution<InputT>>,
142  StaticKernelSolution<InputT>>
143  cls(mod, ("RegularizedKernelSolution" + suffix).c_str());
144 
145  cls.def(py::init<lsst::afw::math::KernelList const &, bool, Eigen::MatrixXd const &,
146  daf::base::PropertySet const&>(),
147  "basisList"_a, "fitForBackground"_a, "hMat"_a, "ps"_a);
148 
149  cls.def("solve",
150  (void (RegularizedKernelSolution<InputT>::*)()) & RegularizedKernelSolution<InputT>::solve);
151  cls.def("getLambda", &RegularizedKernelSolution<InputT>::getLambda);
152  cls.def("estimateRisk", &RegularizedKernelSolution<InputT>::estimateRisk, "maxCond"_a);
153  cls.def("getM", &RegularizedKernelSolution<InputT>::getM);
154 }
155 
159 void declareSpatialKernelSolution(py::module &mod) {
160  py::class_<SpatialKernelSolution, std::shared_ptr<SpatialKernelSolution>, KernelSolution> cls(
161  mod, "SpatialKernelSolution");
162 
164  lsst::afw::math::Kernel::SpatialFunctionPtr, daf::base::PropertySet const&>(),
165  "basisList"_a, "spatialKernelFunction"_a, "background"_a, "ps"_a);
166 
167  cls.def("solve", (void (SpatialKernelSolution::*)()) & SpatialKernelSolution::solve);
168  cls.def("addConstraint", &SpatialKernelSolution::addConstraint, "xCenter"_a, "yCenter"_a, "qMat"_a,
169  "wVec"_a);
170  cls.def("makeKernelImage", &SpatialKernelSolution::makeKernelImage, "pos"_a);
171  cls.def("getSolutionPair", &SpatialKernelSolution::getSolutionPair);
172 }
173 
174 } // namespace lsst::ip::diffim::<anonymous>
175 
176 PYBIND11_MODULE(kernelSolution, mod) {
177  py::module::import("lsst.afw.geom");
178  py::module::import("lsst.afw.image");
179  py::module::import("lsst.afw.math");
180  py::module::import("lsst.daf.base");
181 
182  declareKernelSolution(mod);
183  declareStaticKernelSolution<float>(mod, "F");
184  declareMaskedKernelSolution<float>(mod, "F");
185  declareRegularizedKernelSolution<float>(mod, "F");
186  declareSpatialKernelSolution(mod);
187 }
188 
189 } // diffim
190 } // ip
191 } // lsst
std::string
STL class.
std::shared_ptr
STL class.
std::vector< std::shared_ptr< Kernel > >
KernelSolution.h
Declaration of classes to store the solution for convolution kernels.
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
PropertySet.h
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
lsst::ip::diffim::PYBIND11_MODULE
PYBIND11_MODULE(kernelSolution, mod)
Definition: kernelSolution.cc:176
pybind11
Definition: _GenericMap.cc:40
lsst::utils.tests.init
def init()
Definition: tests.py:58
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42