LSST Applications g0f08755f38+82efc23009,g12f32b3c4e+e7bdf1200e,g1653933729+a8ce1bb630,g1a0ca8cf93+50eff2b06f,g28da252d5a+52db39f6a5,g2bbee38e9b+37c5a29d61,g2bc492864f+37c5a29d61,g2cdde0e794+c05ff076ad,g3156d2b45e+41e33cbcdc,g347aa1857d+37c5a29d61,g35bb328faa+a8ce1bb630,g3a166c0a6a+37c5a29d61,g3e281a1b8c+fb992f5633,g414038480c+7f03dfc1b0,g41af890bb2+11b950c980,g5fbc88fb19+17cd334064,g6b1c1869cb+12dd639c9a,g781aacb6e4+a8ce1bb630,g80478fca09+72e9651da0,g82479be7b0+04c31367b4,g858d7b2824+82efc23009,g9125e01d80+a8ce1bb630,g9726552aa6+8047e3811d,ga5288a1d22+e532dc0a0b,gae0086650b+a8ce1bb630,gb58c049af0+d64f4d3760,gc28159a63d+37c5a29d61,gcf0d15dbbd+2acd6d4d48,gd7358e8bfb+778a810b6e,gda3e153d99+82efc23009,gda6a2b7d83+2acd6d4d48,gdaeeff99f8+1711a396fd,ge2409df99d+6b12de1076,ge79ae78c31+37c5a29d61,gf0baf85859+d0a5978c5a,gf3967379c6+4954f8c433,gfb92a5be7c+82efc23009,gfec2e1e490+2aaed99252,w.2024.46
LSST Data Management Base Package
Loading...
Searching...
No Matches
dipoleAlgorithms.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
23#include "pybind11/pybind11.h"
25#include "pybind11/stl.h"
26
27#include <memory>
28#include <string>
29
32#include "lsst/pex/config/python.h" // for LSST_DECLARE_CONTROL_FIELD
33
34namespace py = pybind11;
35using namespace pybind11::literals;
36
37namespace lsst {
38namespace ip {
39namespace diffim {
40
41namespace {
42
43void declareDipoleCentroidControl(lsst::cpputils::python::WrapperCollection &wrappers) {
44 using PyDipoleCentroidControl = py::class_<DipoleCentroidControl, std::shared_ptr<DipoleCentroidControl>>;
45
46 wrappers.wrapType(PyDipoleCentroidControl(wrappers.module, "DipoleCentroidControl"), [](auto &mod, auto &cls) {
47 cls.def(py::init<>());
48 });
49}
50
51void declareDipoleFluxControl(lsst::cpputils::python::WrapperCollection &wrappers) {
52 using PyDipoleFluxControl = py::class_<DipoleFluxControl, std::shared_ptr<DipoleFluxControl>>;
53
54 wrappers.wrapType(PyDipoleFluxControl(wrappers.module, "DipoleFluxControl"), [](auto &mod, auto &cls) {
55 cls.def(py::init<>());
56 });
57}
58
59void declareDipolePsfFluxControl(lsst::cpputils::python::WrapperCollection &wrappers) {
60 using PyPsfDipoleFluxControl =
61 py::class_<PsfDipoleFluxControl, std::shared_ptr<PsfDipoleFluxControl>, DipoleFluxControl>;
62 wrappers.wrapType(PyPsfDipoleFluxControl(wrappers.module, "PsfDipoleFluxControl"), [](auto &mod, auto &cls) {
63 cls.def(py::init<>());
64
65 LSST_DECLARE_CONTROL_FIELD(cls, PsfDipoleFluxControl, stepSizeCoord);
66 LSST_DECLARE_CONTROL_FIELD(cls, PsfDipoleFluxControl, stepSizeFlux);
67 LSST_DECLARE_CONTROL_FIELD(cls, PsfDipoleFluxControl, errorDef);
68 LSST_DECLARE_CONTROL_FIELD(cls, PsfDipoleFluxControl, maxFnCalls);
69 });
70}
71
72void declareDipoleCentroidAlgorithm(lsst::cpputils::python::WrapperCollection &wrappers) {
73 // Abstract class, so add a leading underscore to Python name and do not wrap constructor
74 using PyDipoleCentroidAlgorithm =
75 py::class_<DipoleCentroidAlgorithm, std::shared_ptr<DipoleCentroidAlgorithm>, meas::base::SimpleAlgorithm>;
76
77 wrappers.wrapType(PyDipoleCentroidAlgorithm(wrappers.module, "_DipoleCentroidAlgorithm"), [](auto &mod, auto &cls) {
78 cls.attr("FAILURE") = py::cast(DipoleCentroidAlgorithm::FAILURE);
79 cls.attr("POS_FLAG") = py::cast(DipoleCentroidAlgorithm::POS_FLAG);
80 cls.attr("NEG_FLAG") = py::cast(DipoleCentroidAlgorithm::NEG_FLAG);
81 cls.def_static("getFlagDefinitions", &DipoleCentroidAlgorithm::getFlagDefinitions,
82 py::return_value_policy::copy);
83
84 cls.def("getPositiveKeys", &DipoleCentroidAlgorithm::getPositiveKeys);
85 cls.def("getNegativeKeys", &DipoleCentroidAlgorithm::getNegativeKeys);
86 });
87}
88
89void declareDipoleFluxAlgorithm(lsst::cpputils::python::WrapperCollection &wrappers) {
90 // Abstract class, so add a leading underscore to Python name and do not wrap constructor
91 using PyDipoleFluxAlgorithm =
92 py::class_<DipoleFluxAlgorithm, std::shared_ptr<DipoleFluxAlgorithm>, meas::base::SimpleAlgorithm>;
93 wrappers.wrapType(PyDipoleFluxAlgorithm(wrappers.module, "_DipoleFluxAlgorithm"), [](auto &mod, auto &cls) {
94 cls.attr("FAILURE") = py::cast(DipoleFluxAlgorithm::FAILURE);
95 cls.attr("POS_FLAG") = py::cast(DipoleFluxAlgorithm::POS_FLAG);
96 cls.attr("NEG_FLAG") = py::cast(DipoleFluxAlgorithm::NEG_FLAG);
97 cls.def_static("getFlagDefinitions", &DipoleFluxAlgorithm::getFlagDefinitions,
98 py::return_value_policy::copy);
99
100 cls.def("getPositiveKeys", &DipoleFluxAlgorithm::getPositiveKeys);
101 cls.def("getNegativeKeys", &DipoleFluxAlgorithm::getNegativeKeys);
102 });
103}
104
105// Hide deprecation warnings when building pybind11.
106// Remove these pragmas on DM-44030
107#pragma GCC diagnostic push
108#pragma GCC diagnostic ignored "-Wdeprecated"
109void declareNaiveDipoleFlux(lsst::cpputils::python::WrapperCollection &wrappers) {
110 using PyNaiveDipoleFlux = py::class_<NaiveDipoleFlux, std::shared_ptr<NaiveDipoleFlux>, DipoleFluxAlgorithm>;
111
112 wrappers.wrapType(PyNaiveDipoleFlux(wrappers.module, "NaiveDipoleFlux"), [](auto &mod, auto &cls) {
113 cls.def(py::init<NaiveDipoleFlux::Control const &, std::string const &, afw::table::Schema &>(), "ctrl"_a,
114 "name"_a, "schema"_a);
115
116 cls.def("measure", &NaiveDipoleFlux::measure, "measRecord"_a, "exposure"_a);
117 cls.def("fail", &NaiveDipoleFlux::fail, "measRecord"_a, "error"_a = nullptr);
118 });
119}
120
121void declareNaiveDipoleCentroid(lsst::cpputils::python::WrapperCollection &wrappers) {
122 using PyNaiveDipoleCentroid =
123 py::class_<NaiveDipoleCentroid, std::shared_ptr<NaiveDipoleCentroid>, DipoleCentroidAlgorithm>;
124 wrappers.wrapType(PyNaiveDipoleCentroid(wrappers.module, "NaiveDipoleCentroid"), [](auto &mod, auto &cls) {
125 cls.def(py::init<NaiveDipoleCentroid::Control const &, std::string const &, afw::table::Schema &>(),
126 "ctrl"_a, "name"_a, "schema"_a);
127
128 cls.def("getCenterKeys", &NaiveDipoleCentroid::getCenterKeys);
129 cls.def("getPositiveKeys", &NaiveDipoleCentroid::getPositiveKeys);
130 cls.def("getNegativeKeys", &NaiveDipoleCentroid::getNegativeKeys);
131
132 cls.def("measure", &NaiveDipoleCentroid::measure, "measRecord"_a, "exposure"_a);
133 cls.def("mergeCentroids", &NaiveDipoleCentroid::mergeCentroids, "source"_a, "posValue"_a, "negValue"_a);
134 cls.def("fail", &NaiveDipoleCentroid::fail, "measRecord"_a, "error"_a = nullptr);
135 });
136}
137
138void declarePsfDipoleFlux(lsst::cpputils::python::WrapperCollection &wrappers) {
139 using PyPsfDipoleFlux = py::class_<PsfDipoleFlux, std::shared_ptr<PsfDipoleFlux>, DipoleFluxAlgorithm>;
140
141 wrappers.wrapType(PyPsfDipoleFlux(wrappers.module, "PsfDipoleFlux"), [](auto &mod, auto &cls) {
142 cls.def(py::init<PsfDipoleFlux::Control const &, std::string const &, afw::table::Schema &>(), "ctrl"_a,
143 "name"_a, "schema"_a);
144
145 cls.def("chi2", &PsfDipoleFlux::chi2, "source"_a, "exposure"_a, "negCenterX"_a, "negCenterY"_a,
146 "negFlux"_a, "posCenterX"_a, "posCenterY"_a, "posFlux"_a);
147 cls.def("measure", &PsfDipoleFlux::measure, "measRecord"_a, "exposure"_a);
148 cls.def("fail", &PsfDipoleFlux::fail, "measRecord"_a, "error"_a = nullptr);
149 });
150}
151
152} // namespace lsst::ip::diffim::<anonymous>
153
155 declareDipoleCentroidControl(wrappers);
156 declareDipoleFluxControl(wrappers);
157 declareDipolePsfFluxControl(wrappers);
158 declareDipoleCentroidAlgorithm(wrappers);
159 declareDipoleFluxAlgorithm(wrappers);
160 declareNaiveDipoleFlux(wrappers);
161 declareNaiveDipoleCentroid(wrappers);
162 declarePsfDipoleFlux(wrappers);
163}
164
165// Stop hiding deprecation warnings when building pybind11.
166// Remove these pragmas on DM-44030
167#pragma GCC diagnostic pop
168
169} // diffim
170} // ip
171} // lsst
A helper class for subdividing pybind11 module across multiple translation units (i....
Definition python.h:242
PyType wrapType(PyType cls, ClassWrapperCallback function, bool setModuleName=true)
Add a type (class or enum) wrapper, deferring method and other attribute definitions until finish() i...
Definition python.h:391
void wrapDipoleAlgorithms(WrapperCollection &wrappers)