mercury/wraprec.cpp at master · albert-physics/mercury · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include "reconstructor.h"
#include "reconstructor_mp.h"

namespace py = pybind11;

PYBIND11_MODULE(mercury, m) {
    py::class_<RecCoG>(m, "RecCoG")
        .def(py::init<std::string &>())

        .def("ProcessEvent", &RecCoG::ProcessEvent)

        .def("getRecX", &RecCoG::getRecX)
        .def("getRecY", &RecCoG::getRecY)

        .def("setCogAbsCutoff", &RecCoG::setCogAbsCutoff)
        .def("setCogRelCutoff", &RecCoG::setCogRelCutoff)
        .def("getSumSignal", &RecCoG::getSumSignal)
        ;

    py::class_<RecLS>(m, "RecLS")
        .def(py::init<std::string &, bool>())

	.def("Version", &RecLS::getVersion)

        .def("ProcessEvent", (bool (RecLS::*) (std::vector <double> &)) &RecLS::ProcessEvent)
        .def("ProcessEvent", (bool (RecLS::*) (std::vector <double> &, std::vector <bool> &)) &RecLS::ProcessEvent)
        .def("ProcessEvent", (bool (RecLS::*) (std::vector <double> &, std::vector <bool> &, std::vector <double> &)) &RecLS::ProcessEvent)

        .def("getGuessX", &RecLS::getGuessX)
        .def("getGuessY", &RecLS::getGuessY)
        .def("getGuessE", &RecLS::getGuessE)
        .def("getRecStatus", &RecLS::getRecStatus)
        .def("getDof", &RecLS::getDof)
        .def("getRecX", &RecLS::getRecX)
        .def("getRecY", &RecLS::getRecY)
        .def("getRecZ", &RecLS::getRecZ)
        .def("getRecE", &RecLS::getRecE)
        .def("getRecMin", &RecLS::getRecMin)
        .def("getChi2Min", &RecLS::getChi2Min)
        .def("getCovXX", &RecLS::getCovXX)
        .def("getCovYY", &RecLS::getCovYY)
        .def("getCovXY", &RecLS::getCovXY)

        .def("setCogAbsCutoff", &RecLS::setCogAbsCutoff)
        .def("setCogRelCutoff", &RecLS::setCogRelCutoff)
        .def("setRecAbsCutoff", &RecLS::setRecAbsCutoff)
        .def("setRecRelCutoff", &RecLS::setRecRelCutoff)
        .def("setRecCutoffRadius", &RecLS::setRecCutoffRadius)
        .def("setEnergyCalibration", &RecLS::setEnergyCalibration)

        .def("setRMstepX", &RecLS::setRMstepX)
        .def("setRMstepY", &RecLS::setRMstepY)
        .def("setRMstepEnergy", &RecLS::setRMstepEnergy)
        .def("setRMmaxFuncCalls", &RecLS::setRMmaxFuncCalls)
        .def("setRMmaxIterations", &RecLS::setRMmaxIterations)
        .def("setRMtolerance", &RecLS::setRMtolerance)

        .def("setMinuitVerbosity", &RecLS::setMinuitVerbosity)

//        .def("setGuessPosition", &RecLS::setGuessPosition)
//        .def("setGuessPositionAuto", &RecLS::setGuessPositionAuto)
//        .def("setGuessEnergy", &RecLS::setGuessEnergy)
//        .def("setGuessEnergyAuto", &RecLS::setGuessEnergyAuto)

        .def("getSumSignal", &RecLS::getSumSignal)
        .def("getSumLRF", &RecLS::getSumLRF)
        .def("getSumActiveSignal", &RecLS::getSumActiveSignal)
        .def("getSumActiveLRF", &RecLS::getSumActiveLRF)

        .def("setAutoE", &RecLS::setAutoE)
        .def("setFixedZ", &RecLS::setFixedZ)
        .def("setFreeZ", &RecLS::setFreeZ)
        ;

    py::class_<RecML>(m, "RecML")
        .def(py::init<std::string &>())

        .def("Version", &RecML::getVersion)
        .def("ProcessEvent", (bool (RecML::*) (std::vector <double> &)) &RecML::ProcessEvent)
        .def("ProcessEvent", (bool (RecML::*) (std::vector <double> &, std::vector <bool> &)) &RecML::ProcessEvent)
        .def("ProcessEvent", (bool (RecML::*) (std::vector <double> &, std::vector <bool> &, std::vector <double> &)) &RecML::ProcessEvent)

        .def("getGuessX", &RecML::getGuessX)
        .def("getGuessY", &RecML::getGuessY)
        .def("getGuessE", &RecML::getGuessE)
        .def("getRecStatus", &RecML::getRecStatus)
        .def("getDof", &RecML::getDof)
        .def("getRecX", &RecML::getRecX)
        .def("getRecY", &RecML::getRecY)
        .def("getRecZ", &RecML::getRecZ)
        .def("getRecE", &RecML::getRecE)
        .def("getRecMin", &RecML::getRecMin)
        .def("getChi2Min", &RecML::getChi2Min)
        .def("getCovXX", &RecML::getCovXX)
        .def("getCovYY", &RecML::getCovYY)
        .def("getCovXY", &RecML::getCovXY)

        .def("setCogAbsCutoff", &RecML::setCogAbsCutoff)
        .def("setCogRelCutoff", &RecML::setCogRelCutoff)
        .def("setRecAbsCutoff", &RecML::setRecAbsCutoff)
        .def("setRecRelCutoff", &RecML::setRecRelCutoff)
        .def("setRecCutoffRadius", &RecML::setRecCutoffRadius)
        .def("setEnergyCalibration", &RecML::setEnergyCalibration)

        .def("setRMstepX", &RecML::setRMstepX)
        .def("setRMstepY", &RecML::setRMstepY)
        .def("setRMstepEnergy", &RecML::setRMstepEnergy)
        .def("setRMmaxFuncCalls", &RecML::setRMmaxFuncCalls)
        .def("setRMmaxIterations", &RecML::setRMmaxIterations)
        .def("setRMtolerance", &RecML::setRMtolerance)

        .def("setMinuitVerbosity", &RecML::setMinuitVerbosity)

//        .def("setGuessPosition", &RecML::setGuessPosition)
//        .def("setGuessPositionAuto", &RecML::setGuessPositionAuto)
//        .def("setGuessEnergy", &RecML::setGuessEnergy)
//        .def("setGuessEnergyAuto", &RecML::setGuessEnergyAuto)

        .def("getSumSignal", &RecML::getSumSignal)
        .def("getSumLRF", &RecML::getSumLRF)
        .def("getSumActiveSignal", &RecML::getSumActiveSignal)
        .def("getSumActiveLRF", &RecML::getSumActiveLRF)

        .def("setAutoE", &RecML::setAutoE)
        .def("setFixedZ", &RecML::setFixedZ)
        .def("setFreeZ", &RecML::setFreeZ)
        ;

        py::class_<ReconstructorMP>(m, "RecCoG_MP")
        .def(py::init<std::string &, int>())

//        .def("ProcessEvents", &ReconstructorMP::ProcessEvents)
        .def("ProcessEvents", (void (ReconstructorMP::*) (std::vector <std::vector <double> > &)) &ReconstructorMP::ProcessEvents)
        .def("ProcessEvents", (void (ReconstructorMP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &)) &ReconstructorMP::ProcessEvents)
        .def("ProcessEvents", (void (ReconstructorMP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &, std::vector <std::vector <double> > &)) &ReconstructorMP::ProcessEvents)

        .def("getRecX", &ReconstructorMP::getRecX)
        .def("getRecY", &ReconstructorMP::getRecY)

        .def("setCogAbsCutoff", &ReconstructorMP::setCogAbsCutoff)
        .def("setCogRelCutoff", &ReconstructorMP::setCogRelCutoff)
        ;

        py::class_<RecLS_MP>(m, "RecLS_MP")
        .def(py::init<std::string &, int, bool>())

//        .def("ProcessEvents", &RecLS_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecLS_MP::*) (std::vector <std::vector <double> > &)) &RecLS_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecLS_MP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &)) &RecLS_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecLS_MP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &, std::vector <std::vector <double> > &)) &RecLS_MP::ProcessEvents)

        .def("getRecStatus", &RecLS_MP::getRecStatus)
        .def("getDof", &RecLS_MP::getDof)
        .def("getRecX", &RecLS_MP::getRecX)
        .def("getRecY", &RecLS_MP::getRecY)
        .def("getRecZ", &RecLS_MP::getRecZ)
        .def("getRecE", &RecLS_MP::getRecE)
        .def("getRecMin", &RecLS_MP::getRecMin)
        .def("getChi2Min", &RecLS_MP::getChi2Min)
        .def("getCovXX", &RecLS_MP::getCovXX)
        .def("getCovYY", &RecLS_MP::getCovYY)
        .def("getCovXY", &RecLS_MP::getCovXY)

        .def("setCogAbsCutoff", &RecLS_MP::setCogAbsCutoff)
        .def("setCogRelCutoff", &RecLS_MP::setCogRelCutoff)
        .def("setRecAbsCutoff", &RecLS_MP::setRecAbsCutoff)
        .def("setRecRelCutoff", &RecLS_MP::setRecRelCutoff)
        .def("setRecCutoffRadius", &RecLS_MP::setRecCutoffRadius)
        .def("setEnergyCalibration", &RecLS_MP::setEnergyCalibration)

        .def("setRMstepX", &RecLS_MP::setRMstepX)
        .def("setRMstepY", &RecLS_MP::setRMstepY)
        .def("setRMstepEnergy", &RecLS_MP::setRMstepEnergy)
        .def("setRMmaxFuncCalls", &RecLS_MP::setRMmaxFuncCalls)
        .def("setRMmaxIterations", &RecLS_MP::setRMmaxIterations)
        .def("setRMtolerance", &RecLS_MP::setRMtolerance)

        .def("setMinuitVerbosity", &RecLS_MP::setMinuitVerbosity)

        .def("setAutoE", &RecLS_MP::setAutoE)
        .def("setFixedZ", &RecLS_MP::setFixedZ)
        .def("setFreeZ", &RecLS_MP::setFreeZ)
        ;

        py::class_<RecML_MP>(m, "RecML_MP")
        .def(py::init<std::string &, int>())

//        .def("ProcessEvents", &RecML_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecML_MP::*) (std::vector <std::vector <double> > &)) &RecML_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecML_MP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &)) &RecML_MP::ProcessEvents)
        .def("ProcessEvents", (void (RecML_MP::*) (std::vector <std::vector <double> > &, std::vector <std::vector <bool> > &, std::vector <std::vector <double> > &)) &RecML_MP::ProcessEvents)


        .def("getRecStatus", &RecML_MP::getRecStatus)
        .def("getDof", &RecML_MP::getDof)
        .def("getRecX", &RecML_MP::getRecX)
        .def("getRecY", &RecML_MP::getRecY)
        .def("getRecZ", &RecML_MP::getRecZ)
        .def("getRecE", &RecML_MP::getRecE)
        .def("getRecMin", &RecML_MP::getRecMin)
        .def("getChi2Min", &RecML_MP::getChi2Min)
        .def("getCovXX", &RecML_MP::getCovXX)
        .def("getCovYY", &RecML_MP::getCovYY)
        .def("getCovXY", &RecML_MP::getCovXY)

        .def("setCogAbsCutoff", &RecML_MP::setCogAbsCutoff)
        .def("setCogRelCutoff", &RecML_MP::setCogRelCutoff)
        .def("setRecAbsCutoff", &RecML_MP::setRecAbsCutoff)
        .def("setRecRelCutoff", &RecML_MP::setRecRelCutoff)
        .def("setRecCutoffRadius", &RecML_MP::setRecCutoffRadius)
        .def("setEnergyCalibration", &RecML_MP::setEnergyCalibration)

        .def("setRMstepX", &RecML_MP::setRMstepX)
        .def("setRMstepY", &RecML_MP::setRMstepY)
        .def("setRMstepEnergy", &RecML_MP::setRMstepEnergy)
        .def("setRMmaxFuncCalls", &RecML_MP::setRMmaxFuncCalls)
        .def("setRMmaxIterations", &RecML_MP::setRMmaxIterations)
        .def("setRMtolerance", &RecML_MP::setRMtolerance)

        .def("setMinuitVerbosity", &RecML_MP::setMinuitVerbosity)

        .def("setAutoE", &RecML_MP::setAutoE)
        .def("setFixedZ", &RecML_MP::setFixedZ)
        .def("setFreeZ", &RecML_MP::setFreeZ)
        ;

}