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
|
#include <pybind11/pybind11.h>
#include <pybind11/operators.h>
#include <pybind11/stl.h>
#include <mshr/CSGGeometry.h>
#include <mshr/CSGPrimitives2D.h>
#include <mshr/CSGPrimitives3D.h>
#include <mshr/CSGCGALDomain2D.h>
#include <mshr/CSGCGALDomain3D.h>
#include <mshr/CSGOperators.h>
#include <mshr/MeshGenerator.h>
#include <mshr/CSGGeometries3D.h>
#include <mshr/CSGCGALMeshGenerator3D.h>
#include <mshr/CSGCGALMeshGenerator2D.h>
#include <mshr/TetgenMeshGenerator3D.h>
#include <mshr/Meshes.h>
namespace py = pybind11;
PYBIND11_MODULE(cpp, m)
{
// Create module for C++ wrappers
m.doc() ="mshr python interface";
// CSGGeometry
py::class_<mshr::CSGGeometry, dolfin::Variable,
std::shared_ptr<mshr::CSGGeometry>> (m, "CSGGeometry")
.def("dim", &mshr::CSGGeometry::dim)
.def("set_subdomain",
static_cast<void(mshr::CSGGeometry::*)(std::size_t i,
std::shared_ptr<mshr::CSGGeometry> s)>(&mshr::CSGGeometry::set_subdomain))
.def("has_subdomains", &mshr::CSGGeometry::has_subdomains)
.def("inside", static_cast<bool (mshr::CSGGeometry::*)(dolfin::Point) const>(&mshr::CSGGeometry::inside))
.def("__mul__",
static_cast<std::shared_ptr<mshr::CSGIntersection>(*)(std::shared_ptr<mshr::CSGGeometry>,
std::shared_ptr<mshr::CSGGeometry>)>(&mshr::operator*),
py::is_operator())
.def("__mul__",
static_cast<std::shared_ptr<mshr::CSGScaling>(*)(std::shared_ptr<mshr::CSGGeometry>,
double)>(&mshr::operator*),
py::is_operator())
.def("__add__",
static_cast<std::shared_ptr<mshr::CSGUnion>(*)(std::shared_ptr<mshr::CSGGeometry>,
std::shared_ptr<mshr::CSGGeometry>)>(&mshr::operator+),
py::is_operator())
.def("__sub__",
static_cast<std::shared_ptr<mshr::CSGDifference>(*)(std::shared_ptr<mshr::CSGGeometry>,
std::shared_ptr<mshr::CSGGeometry>)>(&mshr::operator-),
py::is_operator());
py::class_<mshr::CSGUnion, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGUnion>>(m, "CSGUnion");
py::class_<mshr::CSGIntersection, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGIntersection>>(m, "CSGIntersection");
py::class_<mshr::CSGDifference, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGDifference>>(m, "CSGDifference");
py::class_<mshr::CSGScaling, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGScaling>>(m, "CSGScaling")
.def(py::init<std::shared_ptr<mshr::CSGGeometry>, double>());
py::class_<mshr::CSGTranslation, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGTranslation>>(m, "CSGTranslation")
.def(py::init<std::shared_ptr<mshr::CSGGeometry>, dolfin::Point>());
py::class_<mshr::CSGRotation, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGRotation>>(m, "CSGRotation")
.def(py::init<std::shared_ptr<mshr::CSGGeometry>, dolfin::Point, double>())
.def(py::init<std::shared_ptr<mshr::CSGGeometry>, double>());
// Circle
py::class_<mshr::Circle, mshr::CSGGeometry,
std::shared_ptr<mshr::Circle>>(m, "Circle")
.def(py::init<dolfin::Point, double, std::size_t>(),
py::arg("c"), py::arg("r"), py::arg("segments")=0)
.def("center", &mshr::Circle::center)
.def("radius", &mshr::Circle::radius);
// Ellipse
py::class_<mshr::Ellipse, mshr::CSGGeometry,
std::shared_ptr<mshr::Ellipse>>(m, "Ellipse")
.def(py::init<dolfin::Point, double, double, std::size_t>(),
py::arg("c"), py::arg("a"), py::arg("b"), py::arg("segments")=0)
.def("center", &mshr::Ellipse::center)
.def("a", &mshr::Ellipse::a)
.def("b", &mshr::Ellipse::b);
// Rectangle
py::class_<mshr::Rectangle, mshr::CSGGeometry,
std::shared_ptr<mshr::Rectangle>> (m, "Rectangle")
.def(py::init<dolfin::Point, dolfin::Point>())
.def("first_corner", &mshr::Rectangle::first_corner)
.def("second_corne", &mshr::Rectangle::second_corner);
// Polygon
py::class_<mshr::Polygon, mshr::CSGGeometry,
std::shared_ptr<mshr::Polygon>>(m, "Polygon")
.def(py::init<std::vector<dolfin::Point>&>())
.def("ccw", &mshr::Polygon::ccw)
.def("vertices", &mshr::Polygon::vertices);
// Sphere
py::class_<mshr::Sphere, mshr::CSGGeometry,
std::shared_ptr<mshr::Sphere>>(m, "Sphere")
.def(py::init<dolfin::Point, double, std::size_t>(),
py::arg("center"), py::arg("radius"), py::arg("segments")=10);
// Box
py::class_<mshr::Box, mshr::CSGGeometry,
std::shared_ptr<mshr::Box>>(m, "Box")
.def(py::init<dolfin::Point, dolfin::Point>());
// Cylinder
py::class_<mshr::Cylinder, mshr::CSGGeometry,
std::shared_ptr<mshr::Cylinder>>(m, "Cylinder")
.def(py::init<dolfin::Point, dolfin::Point, double, double, std::size_t>(),
py::arg("top"),
py::arg("bottom"),
py::arg("top_radius"),
py::arg("bottom_radius"),
py::arg("segments")=32);
// Cone
py::class_<mshr::Cone, mshr::Cylinder,
std::shared_ptr<mshr::Cone>>(m, "Cone")
.def(py::init<dolfin::Point, dolfin::Point, double, std::size_t>(),
py::arg("top"), py::arg("bottom"), py::arg("r"), py::arg("segments")=32);
// Tetrahedron
py::class_<mshr::Tetrahedron, mshr::CSGGeometry,
std::shared_ptr<mshr::Tetrahedron>>(m, "Tetrahedron")
.def(py::init<dolfin::Point, dolfin::Point, dolfin::Point, dolfin::Point>());
// Surface3D (deprecated, use CSGCGALDomain3D)
py::class_<mshr::Surface3D, mshr::CSGGeometry,
std::shared_ptr<mshr::Surface3D>>(m, "Surface3D")
.def(py::init<std::string>());
// Ellipsoid
py::class_<mshr::Ellipsoid, mshr::CSGGeometry,
std::shared_ptr<mshr::Ellipsoid>>(m, "Ellipsoid")
.def(py::init<dolfin::Point, double, double, double, std::size_t>(),
py::arg("center"),
py::arg("a"), py::arg("b"), py::arg("c"), py::arg("segments")=15);
// Extrude2D
py::class_<mshr::Extrude2D, mshr::CSGGeometry,
std::shared_ptr<mshr::Extrude2D>>(m, "Extrude2D")
.def(py::init<std::shared_ptr<mshr::CSGGeometry>, double>());
// CSGCGALDomain3D
py::class_<mshr::CSGCGALDomain3D, mshr::CSGGeometry,
std::shared_ptr<mshr::CSGCGALDomain3D>>(m, "CSGCGALDomain3D")
.def(py::init<std::shared_ptr<const mshr::CSGGeometry>>())
.def("num_vertices", &mshr::CSGCGALDomain3D::num_vertices)
.def("num_facets", &mshr::CSGCGALDomain3D::num_facets)
.def("num_halfedges", &mshr::CSGCGALDomain3D::num_halfedges)
.def("num_degenerate_facets", &mshr::CSGCGALDomain3D::num_degenerate_facets)
.def("facet_area_minmax", &mshr::CSGCGALDomain3D::facet_area_minmax)
.def("edge_length_minmax", &mshr::CSGCGALDomain3D::edge_length_range)
.def("num_short_edges", &mshr::CSGCGALDomain3D::num_short_edges)
.def("volume", &mshr::CSGCGALDomain3D::volume)
.def("ensure_meshing_preconditions", &mshr::CSGCGALDomain3D::ensure_meshing_preconditions)
.def("is_selfintersecting", &mshr::CSGCGALDomain3D::is_selfintersecting)
.def("remove_selfintersectione", &mshr::CSGCGALDomain3D::remove_selfintersections)
.def("save", &mshr::CSGCGALDomain3D::save)
.def("num_disconnected_components", &mshr::CSGCGALDomain3D::num_disconnected_components)
.def("num_holes", &mshr::CSGCGALDomain3D::num_holes)
.def("remesh_surface", &mshr::CSGCGALDomain3D::remesh_surface)
.def("remove_degenerate_facets", &mshr::CSGCGALDomain3D::remove_degenerate_facets)
.def("convex_hull", static_cast<std::shared_ptr<mshr::CSGCGALDomain3D>(mshr::CSGCGALDomain3D::*)() const>(&mshr::CSGCGALDomain3D::convex_hull))
;
py::class_<mshr::CSGGeometries>(m, "CSGGeometries")
.def_static("lego", &mshr::CSGGeometries::lego)
.def_static("propeller", &mshr::CSGGeometries::propeller);
py::class_<mshr::UnitSphereMesh>(m, "UnitSphereMesh")
.def(py::init<std::size_t>());
py::class_<mshr::CSGCGALMeshGenerator3D, dolfin::Variable,
std::shared_ptr<mshr::CSGCGALMeshGenerator3D>>(m, "CSGCGALMeshGenerator3D")
.def(py::init<>())
.def("generate", static_cast<std::shared_ptr<dolfin::Mesh>(mshr::CSGCGALMeshGenerator3D::*)(std::shared_ptr<const mshr::CSGCGALDomain3D>) const>(&mshr::CSGCGALMeshGenerator3D::generate));
py::class_<mshr::CSGCGALDomain2D, dolfin::Variable,
std::shared_ptr<mshr::CSGCGALDomain2D>>(m, "CSGCGALDomain2D")
.def(py::init<std::shared_ptr<const mshr::CSGGeometry>, double>());
py::class_<mshr::CSGCGALMeshGenerator2D, dolfin::Variable,
std::shared_ptr<mshr::CSGCGALMeshGenerator2D>>(m, "CSGCGALMeshGenerator2D")
.def(py::init<>())
.def("generate", &mshr::CSGCGALMeshGenerator2D::generate);
py::class_<mshr::TetgenMeshGenerator3D, dolfin::Variable,
std::shared_ptr<mshr::TetgenMeshGenerator3D>>(m, "TetgenMeshGenerator3D")
.def(py::init<>())
.def("generate", &mshr::TetgenMeshGenerator3D::generate);
// generate_mesh
m.def("generate_mesh",
&mshr::generate_mesh,
py::arg("geoemtry"), py::arg("resolution"), py::arg("backend")="cgal");
}
|
