Debian Codegraph @

python/src/io.cpp

raw
1 // Copyright (C) 2017 Chris N. Richardson 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 <string>
20 #include <vector>
21 #include <pybind11/pybind11.h>
22 #include <pybind11/numpy.h>
23 #include <pybind11/stl.h>
24
25 #include <dolfin/io/File.h>
26 #include <dolfin/io/HDF5Attribute.h>
27 #include <dolfin/io/HDF5File.h>
28 #include <dolfin/io/VTKFile.h>
29 #include <dolfin/io/XDMFFile.h>
30 #include <dolfin/io/X3DOM.h>
31 #include <dolfin/function/Function.h>
32 #include <dolfin/geometry/Point.h>
33 #include <dolfin/la/GenericVector.h>
34 #include <dolfin/mesh/Mesh.h>
35 #include <dolfin/mesh/MeshFunction.h>
36 #include <dolfin/mesh/MeshValueCollection.h>
37
38 #include "casters.h"
39
40 namespace py = pybind11;
41
42 namespace dolfin_wrappers
43 {
44
45 void io(py::module& m)
46 {
47 // dolfin::File
48 py::class_<dolfin::File, std::shared_ptr<dolfin::File>>(m, "File")
49 .def(py::init<std::string>())
50 .def(py::init<std::string, std::string>())
51 .def(py::init([](const MPICommWrapper comm, std::string filename)
52 { return std::unique_ptr<dolfin::File>(new dolfin::File(comm.get(), filename)); }),
53 py::arg("comm"), py::arg("filename"))
54 //
55 .def("write", (void (dolfin::File::*)(const dolfin::Parameters&)) &dolfin::File::write)
56 //
57 .def("write", (void (dolfin::File::*)(const dolfin::Mesh&)) &dolfin::File::write)
58 .def("write", (void (dolfin::File::*)(const dolfin::Mesh&, double)) &dolfin::File::write)
59 //
60 .def("write", (void (dolfin::File::*)(const dolfin::Function&)) &dolfin::File::write)
61 .def("write", (void (dolfin::File::*)(const dolfin::Function&, double)) &dolfin::File::write)
62 //
63 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<int>&)) &dolfin::File::write)
64 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<int>&, double)) &dolfin::File::write)
65 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<std::size_t>&)) &dolfin::File::write)
66 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<std::size_t>&, double)) &dolfin::File::write)
67 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<double>&)) &dolfin::File::write)
68 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<double>&, double)) &dolfin::File::write)
69 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<bool>&)) &dolfin::File::write)
70 .def("write", (void (dolfin::File::*)(const dolfin::MeshFunction<bool>&, double)) &dolfin::File::write)
71 //
72 .def("write", (void (dolfin::File::*)(const dolfin::MeshValueCollection<int>&)) &dolfin::File::write)
73 .def("write", (void (dolfin::File::*)(const dolfin::MeshValueCollection<std::size_t>&)) &dolfin::File::write)
74 .def("write", (void (dolfin::File::*)(const dolfin::MeshValueCollection<double>&)) &dolfin::File::write)
75 .def("write", (void (dolfin::File::*)(const dolfin::MeshValueCollection<bool>&)) &dolfin::File::write)
76 //
77 .def("write", (void (dolfin::File::*)(const dolfin::GenericVector&)) &dolfin::File::write)
78 .def("write", (void (dolfin::File::*)(const dolfin::Table&)) &dolfin::File::write)
79 // Unpack
80 .def("write", [](dolfin::File& instance, py::object u)
81 {
82 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
83 instance.write(*_u);
84 })
85 .def("write", [](dolfin::File& instance, py::object u, double t)
86 {
87 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
88 instance.write(*_u, t);
89 })
90 // Read
91 .def("read", (void (dolfin::File::*)(dolfin::Parameters&)) &dolfin::File::read)
92 .def("read", (void (dolfin::File::*)(dolfin::Table&)) &dolfin::File::read)
93 .def("read", (void (dolfin::File::*)(dolfin::GenericVector&)) &dolfin::File::read)
94 .def("read", (void (dolfin::File::*)(dolfin::Function&)) &dolfin::File::read)
95 //
96 .def("read", (void (dolfin::File::*)(dolfin::MeshFunction<bool>&)) &dolfin::File::read)
97 .def("read", (void (dolfin::File::*)(dolfin::MeshFunction<int>&)) &dolfin::File::read)
98 .def("read", (void (dolfin::File::*)(dolfin::MeshFunction<std::size_t>&)) &dolfin::File::read)
99 .def("read", (void (dolfin::File::*)(dolfin::MeshFunction<double>&)) &dolfin::File::read)
100 //
101 .def("read", (void (dolfin::File::*)(dolfin::MeshValueCollection<bool>&)) &dolfin::File::read)
102 .def("read", (void (dolfin::File::*)(dolfin::MeshValueCollection<int>&)) &dolfin::File::read)
103 .def("read", (void (dolfin::File::*)(dolfin::MeshValueCollection<std::size_t>&)) &dolfin::File::read)
104 .def("read", (void (dolfin::File::*)(dolfin::MeshValueCollection<double>&)) &dolfin::File::read)
105 //
106 .def("read", (void (dolfin::File::*)(dolfin::Mesh&)) &dolfin::File::read);
107
108 // dolfin::VTKFile
109 py::class_<dolfin::VTKFile, std::shared_ptr<dolfin::VTKFile>>(m, "VTKFile")
110 .def(py::init<std::string, std::string>())
111 .def("write", [](dolfin::VTKFile& instance, const dolfin::Mesh& mesh)
112 { instance.write(mesh); });
113
114 #ifdef HAS_HDF5
115 // dolfin::HDF5Attribute
116 py::class_<dolfin::HDF5Attribute, std::shared_ptr<dolfin::HDF5Attribute>>(m, "HDF5Attribute")
117 //.def("__getitem__", [](const dolfin::HDF5Attribute& instance, std::string name){ return instance[name]; })
118 .def("__setitem__", [](dolfin::HDF5Attribute& instance, std::string name, std::string value){ instance.set(name, value); })
119 .def("__setitem__", [](dolfin::HDF5Attribute& instance, std::string name, double value){ instance.set(name, value); })
120 .def("__setitem__", [](dolfin::HDF5Attribute& instance, std::string name, std::size_t value){ instance.set(name, value); })
121 .def("__setitem__", [](dolfin::HDF5Attribute& instance, std::string name, py::array_t<double> values)
122 {
123 std::vector<double> _values(values.shape()[0]);
124 std::copy_n(values.data(), _values.size(), _values.begin());
125 instance.set(name, _values);
126 })
127 .def("__setitem__", [](dolfin::HDF5Attribute& instance, std::string name, py::array_t<std::size_t> values)
128 {
129 std::vector<std::size_t> _values(values.shape()[0]);
130 std::copy_n(values.data(), _values.size(), _values.begin());
131 instance.set(name, _values);
132 })
133
134 .def("__getitem__", [](const dolfin::HDF5Attribute& instance, std::string name)
135 {
136 const std::string type = instance.type_str(name);
137 if (type == "string")
138 {
139 std::string attr;
140 instance.get(name, attr);
141 return py::cast(attr);
142 }
143 else if (type == "float")
144 {
145 double attr;
146 instance.get(name, attr);
147 return py::cast(attr);
148 }
149 else if (type == "int")
150 {
151 std::size_t attr;
152 instance.get(name, attr);
153 return py::cast(attr);
154 }
155 else if (type == "vectorfloat")
156 {
157 std::vector<double> attr;
158 instance.get(name, attr);
159 return py::cast(attr);
160 }
161 else if (type == "vectorint")
162 {
163 std::vector<std::size_t> attr;
164 instance.get(name, attr);
165 return py::cast(attr);
166 }
167 else
168 {
169 throw std::runtime_error("HDF5 attribute type unknown.");
170 return py::object();
171 }
172 })
173 .def("__len__", [](const dolfin::HDF5Attribute& self)
174 { return self.list_attributes().size(); })
175 .def("__contains__", [](const dolfin::HDF5Attribute& instance, std::string key)
176 { return instance.exists(key); })
177 .def("to_dict", [](const dolfin::HDF5Attribute& self)
178 {
179 auto d = py::dict();
180 auto names = self.list_attributes();
181 for (auto name : names)
182 {
183 auto type = self.type_str(name);
184 if (type == "string")
185 {
186 std::string a;
187 self.get(name, a);
188 d[name.c_str()] = py::str(a);
189 }
190 else if (type == "float")
191 {
192 double a;
193 self.get(name, a);
194 d[name.c_str()] = py::float_(a);
195 }
196 else if (type == "int")
197 {
198 // This is bad on the DOLFIN cpp side
199 std::size_t a;
200 self.get(name, a);
201 d[name.c_str()] = py::int_(a);
202 }
203 else if (type == "vectorfloat")
204 {
205 std::vector<double> a;
206 self.get(name, a);
207
208 py::array_t<double> data(a.size(), a.data());
209 d[name.c_str()] = data;
210 }
211 else if (type == "vectorint")
212 {
213 // This is bad on the DOLFIN cpp side
214 std::vector<std::size_t> a;
215 self.get(name, a);
216
217 py::array_t<std::size_t> data(a.size(), a.data());
218 d[name.c_str()] = data;
219 }
220 else
221 throw std::runtime_error("Unsupported HDF5 attribute type");
222 }
223
224 return d;
225 })
226 .def("list_attributes", &dolfin::HDF5Attribute::list_attributes)
227 .def("type_str", &dolfin::HDF5Attribute::type_str);
228
229 // dolfin::HDF5File
230 py::class_<dolfin::HDF5File, std::shared_ptr<dolfin::HDF5File>,
231 dolfin::Variable> (m, "HDF5File")
232 .def(py::init([](const MPICommWrapper comm, const std::string filename, const std::string file_mode)
233 { return std::unique_ptr<dolfin::HDF5File>(new dolfin::HDF5File(comm.get(), filename, file_mode)); }),
234 py::arg("comm"), py::arg("filename"), py::arg("file_mode"))
235 .def("__enter__", [](dolfin::HDF5File& self){ return &self; })
236 .def("__exit__", [](dolfin::HDF5File& self, py::args args, py::kwargs kwargs){ self.close(); })
237 .def("close", &dolfin::HDF5File::close)
238 .def("flush", &dolfin::HDF5File::flush)
239 // read
240 .def("read", (void (dolfin::HDF5File::*)(dolfin::Mesh&, std::string, bool) const) &dolfin::HDF5File::read)
241 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshValueCollection<bool>&, std::string) const)
242 &dolfin::HDF5File::read, py::arg("mvc"), py::arg("name"))
243 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshValueCollection<std::size_t>&, std::string) const)
244 &dolfin::HDF5File::read, py::arg("mvc"), py::arg("name"))
245 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshValueCollection<double>&, std::string) const)
246 &dolfin::HDF5File::read, py::arg("mvc"), py::arg("name"))
247 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshFunction<bool>&, std::string) const)
248 &dolfin::HDF5File::read, py::arg("meshfunction"), py::arg("name"))
249 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshFunction<std::size_t>&, std::string) const)
250 &dolfin::HDF5File::read, py::arg("meshfunction"), py::arg("name"))
251 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshFunction<int>&, std::string) const)
252 &dolfin::HDF5File::read, py::arg("meshfunction"), py::arg("name"))
253 .def("read", (void (dolfin::HDF5File::*)(dolfin::MeshFunction<double>&, std::string) const)
254 &dolfin::HDF5File::read, py::arg("meshfunction"), py::arg("name"))
255 .def("read", (void (dolfin::HDF5File::*)(dolfin::GenericVector&, std::string, bool) const)
256 &dolfin::HDF5File::read, py::arg("vector"), py::arg("name"), py::arg("use_partitioning"))
257 .def("read", (void (dolfin::HDF5File::*)(dolfin::Function&, const std::string))
258 &dolfin::HDF5File::read, py::arg("u"), py::arg("name"))
259 .def("read", [](dolfin::HDF5File& self, py::object u, std::string name)
260 {
261 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
262 self.read(*_u, name);
263 }, py::arg("u"), py::arg("name"))
264 // write
265 .def("write", (void (dolfin::HDF5File::*)(const dolfin::Mesh&, std::string)) &dolfin::HDF5File::write)
266 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshValueCollection<bool>&, std::string))
267 &dolfin::HDF5File::write, py::arg("mvc"), py::arg("name"))
268 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshValueCollection<std::size_t>&, std::string))
269 &dolfin::HDF5File::write, py::arg("mvc"), py::arg("name"))
270 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshValueCollection<double>&, std::string))
271 &dolfin::HDF5File::write, py::arg("mvc"), py::arg("name"))
272 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshFunction<bool>&, std::string))
273 &dolfin::HDF5File::write, py::arg("meshfunction"), py::arg("name"))
274 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshFunction<std::size_t>&, std::string))
275 &dolfin::HDF5File::write, py::arg("meshfunction"), py::arg("name"))
276 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshFunction<int>&, std::string))
277 &dolfin::HDF5File::write, py::arg("meshfunction"), py::arg("name"))
278 .def("write", (void (dolfin::HDF5File::*)(const dolfin::MeshFunction<double>&, std::string))
279 &dolfin::HDF5File::write, py::arg("meshfunction"), py::arg("name"))
280 .def("write", (void (dolfin::HDF5File::*)(const dolfin::GenericVector&, std::string))
281 &dolfin::HDF5File::write, py::arg("vector"), py::arg("name"))
282 .def("write", (void (dolfin::HDF5File::*)(const dolfin::Function&, std::string))
283 &dolfin::HDF5File::write, py::arg("u"), py::arg("name"))
284 .def("write", (void (dolfin::HDF5File::*)(const dolfin::Function&, std::string, double))
285 &dolfin::HDF5File::write, py::arg("u"), py::arg("name"), py::arg("t"))
286 .def("write", [](dolfin::HDF5File& self, py::object u, std::string name)
287 {
288 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
289 self.write(*_u, name);
290 }, py::arg("u"), py::arg("name"))
291 .def("write", [](dolfin::HDF5File& self, py::object u, std::string name, double t)
292 {
293 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
294 self.write(*_u, name, t);
295 }, py::arg("u"), py::arg("name"), py::arg("t"))
296 .def("set_mpi_atomicity", &dolfin::HDF5File::set_mpi_atomicity)
297 .def("get_mpi_atomicity", &dolfin::HDF5File::get_mpi_atomicity)
298 // others
299 .def("has_dataset", &dolfin::HDF5File::has_dataset)
300 .def("attributes", &dolfin::HDF5File::attributes);
301
302 #endif
303
304 // dolfin::XDMFFile
305 py::class_<dolfin::XDMFFile, std::shared_ptr<dolfin::XDMFFile>,
306 dolfin::Variable> xdmf_file(m, "XDMFFile");
307
308 xdmf_file
309 .def(py::init([](const MPICommWrapper comm, std::string filename)
310 { return std::unique_ptr<dolfin::XDMFFile>(new dolfin::XDMFFile(comm.get(), filename)); }),
311 py::arg("comm"), py::arg("filename"))
312 .def(py::init<std::string>())
313 .def("__enter__", [](dolfin::XDMFFile& self){ return &self; })
314 .def("__exit__", [](dolfin::XDMFFile& self, py::args args, py::kwargs kwargs){ self.close(); })
315 .def("close", &dolfin::XDMFFile::close);
316
317 // dolfin::XDMFFile::Encoding enums
318 py::enum_<dolfin::XDMFFile::Encoding>(xdmf_file, "Encoding")
319 .value("HDF5", dolfin::XDMFFile::Encoding::HDF5)
320 .value("ASCII", dolfin::XDMFFile::Encoding::ASCII);
321
322 // dolfin::XDMFFile::write
323 xdmf_file
324 // Function
325 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::Function&, dolfin::XDMFFile::Encoding))
326 &dolfin::XDMFFile::write, py::arg("u"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
327 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::Function&, double, dolfin::XDMFFile::Encoding))
328 &dolfin::XDMFFile::write, py::arg("u"), py::arg("t"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
329 // Mesh
330 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::Mesh&, dolfin::XDMFFile::Encoding))
331 &dolfin::XDMFFile::write, py::arg("mesh"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
332 // MeshFunction
333 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshFunction<bool>&, dolfin::XDMFFile::Encoding))
334 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
335 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshFunction<std::size_t>&, dolfin::XDMFFile::Encoding))
336 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
337 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshFunction<int>&, dolfin::XDMFFile::Encoding))
338 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
339 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshFunction<double>&, dolfin::XDMFFile::Encoding))
340 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
341 // MeshValueCollection
342 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshValueCollection<bool>&, dolfin::XDMFFile::Encoding))
343 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
344 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshValueCollection<std::size_t>&, dolfin::XDMFFile::Encoding))
345 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
346 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshValueCollection<int>&, dolfin::XDMFFile::Encoding))
347 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
348 .def("write", (void (dolfin::XDMFFile::*)(const dolfin::MeshValueCollection<double>&, dolfin::XDMFFile::Encoding))
349 &dolfin::XDMFFile::write, py::arg("mvc"), py::arg("encoding") = dolfin::XDMFFile::Encoding::HDF5)
350 // Points
351 .def("write", [](dolfin::XDMFFile& instance, py::list points, dolfin::XDMFFile::Encoding encoding)
352 {
353 auto _points = points.cast<std::vector<dolfin::Point>>();
354 instance.write(_points, encoding);
355 }, py::arg("points"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
356 // Points with values
357 .def("write", [](dolfin::XDMFFile& instance, py::list points, std::vector<double>& values, dolfin::XDMFFile::Encoding encoding)
358 {
359 auto _points = points.cast<std::vector<dolfin::Point>>();
360 instance.write(_points, values, encoding);
361 }, py::arg("points"), py::arg("values"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
362 // py:object / dolfin.function.Function
363 .def("write", [](dolfin::XDMFFile& instance, const py::object u, dolfin::XDMFFile::Encoding encoding)
364 {
365 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
366 instance.write(*_u, encoding);
367 }, py::arg("u"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
368 .def("write", [](dolfin::XDMFFile& instance, const py::object u, double t, dolfin::XDMFFile::Encoding encoding)
369 {
370 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
371 instance.write(*_u, t, encoding);
372 }, py::arg("u"), py::arg("t"), py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5)
373 // Write for checkpointing cpp object
374 .def("write_checkpoint", [](dolfin::XDMFFile& instance, const dolfin::Function& u,
375 std::string function_name,
376 double time_step, dolfin::XDMFFile::Encoding encoding, bool append)
377 { instance.write_checkpoint(u, function_name, time_step, encoding, append); },
378 py::arg("u"), py::arg("function_name"), py::arg("time_step")=0.0,
379 py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5, py::arg("append")=false)
380 // Write for checkpointing dolfin.function.function.Function
381 .def("write_checkpoint", [](dolfin::XDMFFile& instance, const py::object u, std::string function_name,
382 double time_step, dolfin::XDMFFile::Encoding encoding, bool append)
383 {
384 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
385 instance.write_checkpoint(*_u, function_name, time_step, encoding, append);
386 },
387 py::arg("u"), py::arg("function_name"), py::arg("time_step")=0.0,
388 py::arg("encoding")=dolfin::XDMFFile::Encoding::HDF5, py::arg("append")=false);
389
390
391 // XDFMFile::read
392 xdmf_file
393 // Mesh
394 .def("read", (void (dolfin::XDMFFile::*)(dolfin::Mesh&) const) &dolfin::XDMFFile::read)
395 // MeshFunction
396 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshFunction<bool>&, std::string))
397 &dolfin::XDMFFile::read, py::arg("mf"), py::arg("name") = "")
398 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshFunction<std::size_t>&, std::string))
399 &dolfin::XDMFFile::read, py::arg("mf"), py::arg("name") = "")
400 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshFunction<int>&, std::string))
401 &dolfin::XDMFFile::read, py::arg("mf"), py::arg("name") = "")
402 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshFunction<double>&, std::string))
403 &dolfin::XDMFFile::read, py::arg("mf"), py::arg("name") = "")
404 // MeshValueCollection
405 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshValueCollection<bool>&, std::string))
406 &dolfin::XDMFFile::read, py::arg("mvc"), py::arg("name") = "")
407 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshValueCollection<std::size_t>&, std::string))
408 &dolfin::XDMFFile::read, py::arg("mvc"), py::arg("name") = "")
409 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshValueCollection<int>&, std::string))
410 &dolfin::XDMFFile::read, py::arg("mvc"), py::arg("name") = "")
411 .def("read", (void (dolfin::XDMFFile::*)(dolfin::MeshValueCollection<double>&, std::string))
412 &dolfin::XDMFFile::read, py::arg("mvc"), py::arg("name") = "")
413 // Read for checkpointing cpp object
414 .def("read_checkpoint", &dolfin::XDMFFile::read_checkpoint, py::arg("u"), py::arg("name"),
415 py::arg("counter")=-1)
416 // Read for checkpointing dolfin.function.function.Function
417 .def("read_checkpoint", [](dolfin::XDMFFile& instance, py::object u, std::string name, std::int64_t counter)
418 {
419 auto _u = u.attr("_cpp_object").cast<dolfin::Function*>();
420 instance.read_checkpoint(*_u, name, counter);
421 },
422 py::arg("u"), py::arg("name"), py::arg("counter")=-1);
423
424
425 py::class_<dolfin::X3DOMParameters>(m, "X3DOMParameters")
426 .def(py::init<>())
427 .def("get_diffuse_color", &dolfin::X3DOMParameters::get_diffuse_color)
428 .def("set_diffuse_color", [](dolfin::X3DOMParameters& self, py::array_t<double> color)
429 {
430 if (color.ndim() != 1 or color.shape(0) != 3)
431 throw pybind11::type_error("Color must be a 1D array or length 3");
432 self.set_diffuse_color({{*color.data(0), *color.data(1), *color.data(2)}});
433 });
434
435 // dolfin::X3DOM
436 py::class_<dolfin::X3DOM>(m, "X3DOM")
437 .def_static("str", (std::string (*)(const dolfin::Mesh&, dolfin::X3DOMParameters)) &dolfin::X3DOM::str,
438 py::arg("mesh"), py::arg("parameters")=dolfin::X3DOMParameters())
439 .def_static("str", (std::string (*)(const dolfin::Function&, dolfin::X3DOMParameters)) &dolfin::X3DOM::str,
440 py::arg("u"), py::arg("parameters")=dolfin::X3DOMParameters())
441 .def_static("html", (std::string (*)(const dolfin::Mesh&, dolfin::X3DOMParameters)) &dolfin::X3DOM::html,
442 py::arg("mesh"), py::arg("parameters")=dolfin::X3DOMParameters())
443 .def_static("html", (std::string (*)(const dolfin::Function&, dolfin::X3DOMParameters)) &dolfin::X3DOM::html,
444 py::arg("u"), py::arg("parameters")=dolfin::X3DOMParameters());
445
446 }
447 }