Debian Codegraph @

python/src/parameter.cpp

raw
1 // Copyright (C) 2017 Chris Richardson and Garth N. Wells
2 //
3 // This file is part of DOLFIN.
4 //
5 // DOLFIN is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // DOLFIN is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public License
16 // along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
17
18 #include <memory>
19 #include <pybind11/pybind11.h>
20 #include <pybind11/numpy.h>
21 #include <pybind11/stl.h>
22
23 #include <dolfin/parameter/GlobalParameters.h>
24 #include <dolfin/parameter/Parameter.h>
25 #include <dolfin/parameter/Parameters.h>
26 #include "casters.h"
27
28 namespace py = pybind11;
29
30 namespace dolfin_wrappers
31 {
32
33 void parameter(py::module& m)
34 {
35
36 // dolfin::Parameters
37 py::class_<dolfin::Parameters, std::shared_ptr<dolfin::Parameters>>
38 (m, "Parameters")
39 .def(py::init<>())
40 .def(py::init<std::string>())
41 .def(py::init<dolfin::Parameters>())
42 .def(py::init([](std::string name, py::kwargs kwargs)
43 {
44 dolfin::Parameters p(name);
45 if (kwargs)
46 {
47 for (auto item : kwargs)
48 {
49 std::string key = std::string(py::str(item.first));
50 auto value = item.second;
51 if (py::isinstance<py::str>(value))
52 p.add(key, value.cast<std::string>());
53 else if (py::isinstance<py::int_>(value))
54 p.add(key, value.cast<int>());
55 else if (py::isinstance<py::float_>(value))
56 p.add(key, value.cast<double>());
57 else if (py::isinstance<dolfin::Parameters>(value))
58 p.add(value.cast<dolfin::Parameters>());
59 else if (py::isinstance<py::tuple>(value))
60 {
61 auto t = value.cast<py::tuple>();
62 if (t.size() == 2)
63 p.add(key, t[0].cast<std::string>(), t[1].cast<std::set<std::string>>());
64 if (t.size() == 3)
65 {
66 if (py::isinstance<py::float_>(t[0]))
67 p.add(key, t[0].cast<double>(), t[1].cast<double>(), t[2].cast<double>());
68 else if (py::isinstance<py::int_>(t[0]))
69 p.add(key, t[0].cast<int>(), t[1].cast<int>(), t[2].cast<int>());
70 else
71 throw std::runtime_error("Unknown parameter type with range - expecting int or float");
72 }
73 }
74 else
75 throw std::runtime_error("Unknown parameter type.");
76 }
77 }
78
79 return p;
80 }
81 ))
82 // Use boost::variant to simplify
83 .def("add", (void (dolfin::Parameters::*)(std::string, std::string)) &dolfin::Parameters::add)
84 .def("add", (void (dolfin::Parameters::*)(std::string, std::string, std::set<std::string>)) &dolfin::Parameters::add)
85 .def("add", (void (dolfin::Parameters::*)(std::string, bool)) &dolfin::Parameters::add)
86 .def("add", (void (dolfin::Parameters::*)(std::string, int, int, int)) &dolfin::Parameters::add)
87 .def("add", (void (dolfin::Parameters::*)(std::string, int)) &dolfin::Parameters::add)
88 .def("add", (void (dolfin::Parameters::*)(std::string, double)) &dolfin::Parameters::add)
89 .def("add", (void (dolfin::Parameters::*)(std::string, double, double, double)) &dolfin::Parameters::add)
90 .def("add", (void (dolfin::Parameters::*)(const dolfin::Parameters&)) &dolfin::Parameters::add)
91 // Support iterators
92 .def("__len__", &dolfin::Parameters::size)
93 .def("__iter__", [](const dolfin::Parameters& p) { return py::make_key_iterator(p.begin(), p.end()); },
94 py::keep_alive<0, 1>())
95 .def("items", [](const dolfin::Parameters& p) { return py::make_iterator(p.begin(), p.end()); },
96 py::keep_alive<0, 1>())
97 .def("keys", [](const dolfin::Parameters& p)
98 {
99 std::vector<std::string> keys;
100 for (auto &q : p)
101 keys.push_back(q.first);
102 return keys;
103 })
104 // These set_range function should be remove - they're just duplication
105 .def("set_range", [](dolfin::Parameters& self, std::string name, double min, double max)
106 { self[name].set_range(min, max);} )
107 .def("set_range", [](dolfin::Parameters& self, std::string name, int min, int max)
108 { self[name].set_range(min, max);} )
109 .def("set_range", [](dolfin::Parameters& self, std::string name, std::set<std::string> range)
110 { self[name].set_range(range);} )
111 .def("get_range", [](dolfin::Parameters& self, std::string key)
112 {
113 const auto& p = self.find_parameter(key);
114 std::set<std::string> range;
115 p->get_range(range);
116 return range;
117 })
118 .def("name", &dolfin::Parameters::name)
119 .def("rename", &dolfin::Parameters::rename)
120 .def("str", &dolfin::Parameters::str)
121 .def("has_parameter", &dolfin::Parameters::has_parameter)
122 .def("has_parameter_set", &dolfin::Parameters::has_parameter_set)
123 .def("_update", &dolfin::Parameters::update)
124 .def("_get_parameter", (dolfin::Parameter& (dolfin::Parameters::*)(std::string))
125 &dolfin::Parameters::operator[], py::return_value_policy::reference)
126 .def("_get_parameter_set", (dolfin::Parameters& (dolfin::Parameters::*)(std::string))
127 &dolfin::Parameters::operator(), py::return_value_policy::reference)
128 /*
129 // With boost::variant, need to figure out how to set the
130 // return policy per type in variant
131 .def("__getitem__", [](dolfin::Parameters& self, std::string key)
132 {
133 mapbox::util::variant<bool, int, double, std::string, dolfin::Parameters*> v;
134 auto param = self.find_parameter(key);
135 if (auto param = self.find_parameter(key))
136 {
137 // FIXME: This will be simple once boost::variant is working
138 //return param->value();
139 auto _v = param->value();
140 if (_v.which() == 1)
141 v = boost::get<bool>(_v);
142 else if (_v.which() == 2)
143 v = boost::get<int>(_v);
144 else if (_v.which() == 3)
145 v = boost::get<double>(_v);
146 else if (_v.which() == 4)
147 v = boost::get<std::string>(_v);
148 else
149 throw std::runtime_error("Cannot get parameter value");
150 return v;
151 }
152 else if (auto param = self.find_parameter_set(key))
153 {
154 //v = &(*param);
155 v = &self("key");
156 return v;
157 }
158 else
159 throw std::runtime_error("Invalid parameter key: " + key);
160 }, py::return_value_policy::automatic_reference)
161 */
162 // FIXME: Implement checks and error handling below
163 // FIXME: Can these functions be consolidated. Maybe boost::variant can help?
164 .def("__setitem__", [](dolfin::Parameters& self, std::string key, py::none value)
165 {
166 auto param = self.find_parameter(key);
167 if (!param)
168 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
169 param->reset();
170 }, "Reset Parameter (mark as unset) by setting to None.")
171 .def("__setitem__", [](dolfin::Parameters& self, std::string key, bool value)
172 {
173 auto param = self.find_parameter(key);
174 if (!param)
175 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
176 *param = value;
177 }, py::arg(), py::arg().noconvert())
178 .def("__setitem__", [](dolfin::Parameters& self, std::string key, std::string value)
179 {
180 auto param = self.find_parameter(key);
181 if (!param)
182 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
183 *param = value;
184 })
185 .def("__setitem__", [](dolfin::Parameters& self, std::string key, int value)
186 {
187 auto param = self.find_parameter(key);
188 if (!param)
189 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
190 *param = value;
191 })
192 .def("__setitem__", [](dolfin::Parameters& self, std::string key, double value)
193 {
194 auto param = self.find_parameter(key);
195 if (!param)
196 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
197 *param = value;
198 })
199 .def("__setitem__", [](dolfin::Parameters& self, std::string key, const dolfin::Parameters& other)
200 {
201 auto param = self.find_parameter_set(key);
202 if (!param)
203 throw std::runtime_error("Parameter " + key + " not found in Parameters object");
204 *param = other;
205 })
206 .def("__getitem__", [](dolfin::Parameters& self, std::string key)
207 {
208 return self[key];
209 })
210 .def("parse", [](dolfin::Parameters& self, py::list argv)
211 {
212 if (argv.size() == 0)
213 argv = py::module::import("sys").attr("argv").cast<py::list>();
214
215 const int argc = argv.size();
216
217 std::vector<std::string> a;
218 for (auto q : argv)
219 a.push_back(q.cast<std::string>());
220
221 char* char_args[argc];
222 for (int j=0; j<argc; ++j)
223 char_args[j] = &(a[j].front());
224
225 self.parse(argc, char_args);
226 }, py::arg("argv")=py::list())
227 .def("copy", [](dolfin::Parameters& self) { return dolfin::Parameters(self); })
228 .def("assign", [](dolfin::Parameters& self, dolfin::Parameters& other) { self = other; });
229
230 // dolfin::Parameter
231 py::class_<dolfin::Parameter, std::shared_ptr<dolfin::Parameter>>(m, "Parameter")
232 .def("value", [](const dolfin::Parameter& self)
233 {
234 py::object value;
235 if (self.is_set())
236 value = py::cast(self.value());
237 else
238 value = py::none();
239 return value;
240 })
241 .def("set_range", (void (dolfin::Parameter::*)(double, double)) &dolfin::Parameter::set_range)
242 .def("set_range", (void (dolfin::Parameter::*)(int, int)) &dolfin::Parameter::set_range)
243 .def("set_range", (void (dolfin::Parameter::*)(std::set<std::string>)) &dolfin::Parameter::set_range)
244 .def("__str__", &dolfin::Parameter::value_str);
245
246 // dolfin::GlobalParameters
247 py::class_<dolfin::GlobalParameters, std::shared_ptr<dolfin::GlobalParameters>,
248 dolfin::Parameters> (m, "GlobalParameters");
249
250 // The global parameters (return a reference because there should
251 // be only one instance)
252 m.attr("parameters") = &dolfin::parameters;
253 }
254 }