Skip to content

Commit 345e46b

Browse files
Deepanshu2017Deepanshu2017
committed
PhaseSpace all methods complete working with Events
Signed-off-by: Deepanshu <deepanshu2017@gmail.com>
1 parent 7db2fa4 commit 345e46b

4 files changed

Lines changed: 105 additions & 74 deletions

File tree

‎include/PyPhaseSpace.h‎

Lines changed: 92 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -56,25 +56,10 @@ namespace py = pybind11;
5656

5757
namespace hydra_python {
5858

59-
#define PHASESPACE_GENERATE_BODY(N, RNG, BACKEND) \
60-
"Generate" #BACKEND, \
61-
[](hydra::PhaseSpace<N, RNG>& p, hydra::Vector4R& vec, \
62-
hydra::Events<N, hydra::BACKEND::sys_t>& e) { \
63-
p.Generate(vec, e.begin(), e.end()); \
64-
}
65-
66-
#define PHASESPACE_GENERATE_BODY_2(N, RNG, BACKEND) \
67-
"Generate" #BACKEND, [](hydra::PhaseSpace<N, RNG>& p, \
68-
hydra::Events<N, hydra::BACKEND::sys_t>& e1, \
69-
hydra::Events<N, hydra::BACKEND::sys_t>& e2) { \
70-
p.Generate(e1.DaughtersBegin(0), e1.DaughtersEnd(0), \
71-
e2.begin()); \
72-
}
73-
74-
#define ADD_FUNCTOR(...) \
75-
auto functor = [=](hydra::Vector4R* data) { \
76-
return funct(__VA_ARGS__).cast<double>(); \
77-
}; \
59+
#define ADD_FUNCTOR(...) \
60+
auto functor = [=](unsigned int n, hydra::Vector4R* data) { \
61+
return funct(__VA_ARGS__).cast<double>(); \
62+
}; \
7863
auto wfunctor = hydra::wrap_lambda(functor);
7964

8065
#define ADD1 data[0]
@@ -93,59 +78,102 @@ namespace hydra_python {
9378
data[0], data[1], data[2], data[3], data[4], data[5], data[6], \
9479
data[7], data[8], data[9]
9580

96-
#define PHASESPACE_AVERAGEON_BODY(N, RNG, BACKEND) \
97-
"AverageON" #BACKEND, \
98-
[](hydra::PhaseSpace<N, RNG>& p, hydra::Vector4R& v, \
99-
py::function& funct, size_t nentries) { \
100-
ADD_FUNCTOR(ADD##N) \
101-
return p.AverageOn(hydra::BACKEND::sys, v, wfunctor, \
102-
nentries); \
103-
}
81+
#define ADDAVG1 data[0], data[1]
82+
#define ADDAVG2 data[0], data[1], data[2]
83+
#define ADDAVG3 data[0], data[1], data[2], data[3]
84+
#define ADDAVG4 data[0], data[1], data[2], data[3], data[4]
85+
#define ADDAVG5 data[0], data[1], data[2], data[3], data[4], data[5]
86+
#define ADDAVG6 data[0], data[1], data[2], data[3], data[4], data[5], data[6]
87+
#define ADDAVG7 \
88+
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]
89+
#define ADDAVG8 \
90+
data[0], data[1], data[2], data[3], data[4], data[5], data[6], \
91+
data[7], data[8]
92+
#define ADDAVG9 \
93+
data[0], data[1], data[2], data[3], data[4], data[5], data[6], \
94+
data[7], data[8], data[9]
95+
#define ADDAVG10 \
96+
data[0], data[1], data[2], data[3], data[4], data[5], data[6], \
97+
data[7], data[8], data[9], data[10]
10498

105-
#define PHASESPACE_AVERAGEON_BODY_2(N, RNG, BACKEND) \
106-
"AverageON" #BACKEND, [](hydra::PhaseSpace<N, RNG>& p, \
107-
hydra::Events<N, hydra::BACKEND::sys_t>& e, \
108-
py::function& fun) { return 42.0; }
99+
#define GENERATE_ON_EVENT(N, RNG, BACKEND) \
100+
.def("GenerateOn" #BACKEND, \
101+
[](hydra::PhaseSpace<N, RNG>& p, hydra::Vector4R& mother, \
102+
hydra::Events<N, hydra::BACKEND::sys_t>& event_container) { \
103+
p.Generate(mother, event_container.begin(), \
104+
event_container.end()); \
105+
}) \
106+
.def( \
107+
"GenerateOn" #BACKEND, \
108+
[](hydra::PhaseSpace<N, RNG>& p, \
109+
hypy::BACKEND##_vector_float4& mothers, \
110+
hydra::Events<N, hydra::BACKEND::sys_t>& event_container) { \
111+
p.Generate(mothers.begin(), mothers.end(), \
112+
event_container.begin()); \
113+
})
109114

110-
/*
115+
#define AVERAGE_ON_EVENT(N, RNG, BACKEND) \
116+
.def("AverageOn" #BACKEND, \
117+
[](hydra::PhaseSpace<N, RNG>& p, hydra::Vector4R& mother, \
118+
py::function& funct, size_t nentries) { \
119+
ADD_FUNCTOR(ADD##N) \
120+
return p.AverageOn(hydra::BACKEND::sys, mother, wfunctor, \
121+
nentries); \
122+
}) \
123+
.def("AverageOn" #BACKEND, \
124+
[](hydra::PhaseSpace<N, RNG>& p, \
125+
hypy::BACKEND##_vector_float4& mothers, \
126+
py::function& funct) { \
127+
ADD_FUNCTOR(ADDAVG##N) \
128+
return p.AverageOn(mothers.begin(), mothers.end(), \
129+
wfunctor); \
130+
})
111131

112-
#define PHASESPACE_GENERATE_BODY_2(N, RNG, BACKEND) "Generate"#BACKEND,
113-
[](hydra::PhaseSpace<N, RNG>& p, hydra::Events<N, hydra::BACKEND::sys_t>& e1,
114-
hydra::Events<N, hydra::BACKEND::sys_t>& e2) {\
115-
p.Generate(e1.DaughtersBegin(0), e1.DaughtersEnd(0), e2.begin());\
116-
}
117-
*/
132+
#define EVALUATE_ON_EVENT(N, RNG, BACKEND) \
133+
.def("EvaluateOn" #BACKEND, \
134+
[](hydra::PhaseSpace<N, RNG>& p, hydra::Vector4R& mother, \
135+
hypy::BACKEND##_vector_float2& container, \
136+
py::function& funct) { \
137+
ADD_FUNCTOR(ADD5) \
138+
return p.Evaluate(mother, container.begin(), \
139+
container.end(), wfunctor); \
140+
}) \
141+
.def("EvaluateOn" #BACKEND, \
142+
[](hydra::PhaseSpace<N, RNG>& p, \
143+
hypy::BACKEND##_vector_float4& mothers, \
144+
hypy::BACKEND##_vector_float2& container, \
145+
py::function& funct) { \
146+
ADD_FUNCTOR(ADD5) \
147+
p.Evaluate(mothers.begin(), mothers.end(), \
148+
container.begin(), wfunctor); \
149+
})
118150

119-
#define PHASESPACE_CLASS_BODY(N, RNG, BACKEND) \
120-
py::class_<hydra::PhaseSpace<N, RNG>>(m, "PhaseSpace" #N) \
121-
.def(py::init<hydra::GReal_t, \
122-
const std::array<hydra::GReal_t, N>&>()) \
123-
.def("GetSeed", &hydra::PhaseSpace<N, RNG>::GetSeed) \
124-
.def("SetSeed", &hydra::PhaseSpace<N, RNG>::SetSeed) \
125-
.def(PHASESPACE_GENERATE_BODY(N, RNG, host)) \
126-
.def(PHASESPACE_GENERATE_BODY(N, RNG, device)) \
127-
.def(PHASESPACE_AVERAGEON_BODY(N, RNG, host)) \
128-
.def(PHASESPACE_AVERAGEON_BODY(N, RNG, device)) \
129-
.def(PHASESPACE_AVERAGEON_BODY_2(N, RNG, host)) \
130-
.def(PHASESPACE_AVERAGEON_BODY_2(N, RNG, device));
131-
/*
132-
.def(PHASESPACE_GENERATE_BODY_2(N, RNG, host)) \
133-
.def(PHASESPACE_GENERATE_BODY_2(N, RNG, device));
134-
*/
151+
#define PHASESPACE_CLASS_BODY(N, RNG) \
152+
py::class_<hydra::PhaseSpace<N, RNG>>(m, "PhaseSpace" #N) \
153+
.def(py::init<hydra::GReal_t, \
154+
const std::array<hydra::GReal_t, N>&>()) \
155+
.def("GetSeed", &hydra::PhaseSpace<N, RNG>::GetSeed) \
156+
.def("SetSeed", &hydra::PhaseSpace<N, RNG>::SetSeed) \
157+
GENERATE_ON_EVENT(N, RNG, host)\
158+
AVERAGE_ON_EVENT(N, RNG, host) \
159+
EVALUATE_ON_EVENT(N, RNG, host) \
160+
GENERATE_ON_EVENT(N, RNG, device) \
161+
AVERAGE_ON_EVENT(N, RNG, device) \
162+
EVALUATE_ON_EVENT(N, RNG, device);
135163

136164
template <>
137165
void add_object<hydra::PhaseSpace<4, thrust::random::default_random_engine>>(
138166
pybind11::module& m) {
139-
PHASESPACE_CLASS_BODY(1, thrust::random::default_random_engine, host);
140-
PHASESPACE_CLASS_BODY(2, thrust::random::default_random_engine, host);
141-
PHASESPACE_CLASS_BODY(3, thrust::random::default_random_engine, host);
142-
PHASESPACE_CLASS_BODY(4, thrust::random::default_random_engine, host);
143-
PHASESPACE_CLASS_BODY(5, thrust::random::default_random_engine, host);
144-
PHASESPACE_CLASS_BODY(6, thrust::random::default_random_engine, host);
145-
PHASESPACE_CLASS_BODY(7, thrust::random::default_random_engine, host);
146-
PHASESPACE_CLASS_BODY(8, thrust::random::default_random_engine, host);
147-
PHASESPACE_CLASS_BODY(9, thrust::random::default_random_engine, host);
148-
PHASESPACE_CLASS_BODY(10, thrust::random::default_random_engine, host);
167+
PHASESPACE_CLASS_BODY(1, thrust::random::default_random_engine);
168+
PHASESPACE_CLASS_BODY(2, thrust::random::default_random_engine);
169+
PHASESPACE_CLASS_BODY(3, thrust::random::default_random_engine);
170+
PHASESPACE_CLASS_BODY(4, thrust::random::default_random_engine);
171+
PHASESPACE_CLASS_BODY(5, thrust::random::default_random_engine);
172+
PHASESPACE_CLASS_BODY(6, thrust::random::default_random_engine);
173+
PHASESPACE_CLASS_BODY(7, thrust::random::default_random_engine);
174+
PHASESPACE_CLASS_BODY(8, thrust::random::default_random_engine);
175+
PHASESPACE_CLASS_BODY(9, thrust::random::default_random_engine);
176+
PHASESPACE_CLASS_BODY(10, thrust::random::default_random_engine);
149177
}
150178
}
151179
#endif /* PYPHASESPACE_H_ */

‎include/PyRandom.h‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ std::array<double,N>const& min,\
5555
std::array<double,N>const& max,\
5656
py::function& funct)\
5757
{\
58-
auto functor = [=](double* data) {return funct( __VA_ARGS__ ).cast<double>();}; \
58+
auto functor = [=](unsigned int n, double* data) {return funct( __VA_ARGS__ ).cast<double>();}; \
5959
auto wfunctor = hydra::wrap_lambda( functor ); \
6060
auto middle = cobj.Sample(vect.begin(), vect.end(), min, max, wfunctor ); \
6161
typedef decltype(vect.begin()) iter_t;\
@@ -76,7 +76,7 @@ void add_object<hydra::Random<> >(pybind11::module& m) {
7676
[](hydra::Random<>& cobj, size_t seed) {cobj.SetSeed(seed);},
7777
"Set seed of the underlying random number generator.")
7878
//get seed
79-
.def("GetSeed", [](hydra::Random<>& cobj) {return cobj.GetSeed();},
79+
.def("GetSeed", [](hydra::Random<>& cobj) {cobj.GetSeed();},
8080
"Get seed of the underlying random number generator.")
8181
//-----------------------------------------------------
8282
//host functions
@@ -109,9 +109,9 @@ void add_object<hydra::Random<> >(pybind11::module& m) {
109109
[](hydra::Random<>& cobj, host_vector_float& vect,
110110
double min, double max, py::function& funct) {
111111

112-
auto functor = [=](double* data) {return funct(data[0]).cast<double>();};
113-
114-
auto middle = cobj.Sample(vect.begin(), vect.end(), min, max, functor );
112+
auto functor = [=](unsigned int n, double* data) {return funct(data[0]).cast<double>();};
113+
auto wfunctor = hydra::wrap_lambda( functor );
114+
auto middle = cobj.Sample(vect.begin(), vect.end(), min, max, wfunctor );
115115

116116
typedef decltype(vect.begin()) iter_t;
117117

@@ -159,9 +159,9 @@ void add_object<hydra::Random<> >(pybind11::module& m) {
159159
[](hydra::Random<>& cobj, device_vector_float& vect,
160160
double min, double max, py::function& funct) {
161161

162-
auto functor = [=](double* data) {return funct(data[0]).cast<double>();};
163-
164-
auto middle = cobj.Sample(vect.begin(), vect.end(), min, max, functor );
162+
auto functor = [=](unsigned int n, double* data) {return funct(data[0]).cast<double>();};
163+
auto wfunctor = hydra::wrap_lambda( functor );
164+
auto middle = cobj.Sample(vect.begin(), vect.end(), min, max, wfunctor );
165165
typedef decltype(vect.begin()) iter_t;
166166
return py::make_iterator<pybind11::return_value_policy::reference_internal,iter_t, iter_t,
167167
typename iter_t::value_type>(vect.begin(),middle);

‎include/bind_container.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@
4444
#define BIND_CONTAINER_H_
4545

4646

47-
#include "pybind11/common.h"
47+
#include "pybind11/detail/common.h"
4848
#include "pybind11/operators.h"
4949

5050
#include <thrust/find.h>
@@ -454,6 +454,9 @@ pybind11::class_<Vector, holder_type> bind_vector(pybind11::module &m, std::stri
454454
// Accessor and iterator; return by value if copyable, otherwise we return by ref + keep-alive
455455
detail::vector_accessor<Vector, Class_>(cl);
456456

457+
cl.def("get_range", [](Vector& v){return std::make_pair(v.begin(),v.end());},"get_range function"
458+
459+
);
457460

458461
cl.def("__bool__",
459462
[](const Vector &v) -> bool {

‎include/casters.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
12
/*----------------------------------------------------------------------------
23
*
34
* Copyright (C) 2017 Antonio Augusto Alves Junior
@@ -276,4 +277,3 @@ template <typename T1, typename T2> class type_caster<hydra::pair<T1, T2>>
276277

277278

278279
#endif /* CASTERS_H_ */
279-

0 commit comments

Comments
 (0)