Debian Codegraph @

src/atlas/meshgenerator/detail/DelaunayMeshGenerator.cc

raw
1 /*
2 * (C) Copyright 2013 ECMWF.
3 *
4 * This software is licensed under the terms of the Apache Licence Version 2.0
5 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6 * In applying this licence, ECMWF does not waive the privileges and immunities
7 * granted to it by virtue of its status as an intergovernmental organisation
8 * nor does it submit to any jurisdiction.
9 */
10
11 #include <unordered_map>
12
13 #include "eckit/utils/Hash.h"
14
15 #include "atlas/array/ArrayView.h"
16 #include "atlas/array/MakeView.h"
17 #include "atlas/field/Field.h"
18 #include "atlas/grid/Distribution.h"
19 #include "atlas/grid/Grid.h"
20 #include "atlas/grid/Iterator.h"
21 #include "atlas/mesh/ElementType.h"
22 #include "atlas/mesh/HybridElements.h"
23 #include "atlas/mesh/Mesh.h"
24 #include "atlas/mesh/Nodes.h"
25 #include "atlas/mesh/actions/BuildConvexHull3D.h"
26 #include "atlas/mesh/actions/BuildXYZField.h"
27 #include "atlas/mesh/actions/ExtendNodesGlobal.h"
28 #include "atlas/meshgenerator/detail/DelaunayMeshGenerator.h"
29 #include "atlas/meshgenerator/detail/MeshGeneratorFactory.h"
30 #include "atlas/parallel/mpi/mpi.h"
31 #include "atlas/projection/Projection.h"
32 #include "atlas/runtime/Log.h"
33 #include "atlas/util/Config.h"
34 #include "atlas/util/CoordinateEnums.h"
35
36 using atlas::Mesh;
37
38 namespace atlas {
39 namespace meshgenerator {
40
41 //----------------------------------------------------------------------------------------------------------------------
42
43 DelaunayMeshGenerator::DelaunayMeshGenerator(const eckit::Parametrisation& p) {
44 p.get("mpi_comm",mpi_comm_=mpi::comm().name());
45 p.get("part",part_=mpi::comm(mpi_comm_).rank());
46 p.get("reshuffle",reshuffle_=true);
47 p.get("remove_duplicate_points",remove_duplicate_points_=true);
48 p.get("extension_grid", extension_grid_);
49 }
50
51 DelaunayMeshGenerator::~DelaunayMeshGenerator() = default;
52
53 void DelaunayMeshGenerator::hash(eckit::Hash& h) const {
54 h.add("Delaunay");
55
56 // no other settings
57 }
58
59 void DelaunayMeshGenerator::generate(const Grid& grid, const grid::Distribution& dist, Mesh& mesh) const {
60
61 mpi::Scope mpi_scope(mpi_comm_);
62
63 auto build_global_mesh = [&](Mesh& mesh) {
64 idx_t nb_nodes = grid.size();
65 mesh.nodes().resize(nb_nodes);
66 auto xy = array::make_view<double, 2>(mesh.nodes().xy());
67 auto lonlat = array::make_view<double, 2>(mesh.nodes().lonlat());
68 auto ghost = array::make_view<int, 1>(mesh.nodes().ghost());
69 auto gidx = array::make_view<gidx_t, 1>(mesh.nodes().global_index());
70 auto part = array::make_view<int, 1>(mesh.nodes().partition());
71 auto flags = array::make_view<int, 1>(mesh.nodes().flags());
72
73 size_t jnode{0};
74 Projection projection = grid.projection();
75 PointLonLat Pll;
76 for (PointXY Pxy : grid.xy()) {
77 xy(jnode, size_t(XX)) = Pxy.x();
78 xy(jnode, size_t(YY)) = Pxy.y();
79
80 Pll = projection.lonlat(Pxy);
81 lonlat(jnode, size_t(LON)) = Pll.lon();
82 lonlat(jnode, size_t(LAT)) = Pll.lat();
83
84 part(jnode) = dist.partition(jnode);
85 ghost(jnode) = part(jnode) != part_;
86
87 gidx(jnode) = jnode + 1;
88
89 if (ghost(jnode)) {
90 util::Topology::view(flags(jnode)).set(util::Topology::GHOST);
91 }
92
93 ++jnode;
94 }
95
96 mesh::actions::BuildXYZField()(mesh);
97 mesh::actions::ExtendNodesGlobal{extension_grid_}(grid, mesh); ///< does nothing if global domain
98 mesh::actions::BuildConvexHull3D()(mesh);
99
100 auto cells_gidx = array::make_view<gidx_t, 1>(mesh.cells().global_index());
101 for (idx_t jelem=0; jelem<mesh.cells().size(); ++jelem) {
102 cells_gidx(jelem) = jelem + 1;
103 }
104 };
105
106 if( dist.nb_partitions() == 1 ) {
107 build_global_mesh(mesh);
108 setGrid(mesh, grid, dist.type());
109 mesh.metadata().set("mpi_comm",mpi_comm_);
110 return;
111 }
112
113 Mesh global_mesh;
114 build_global_mesh(global_mesh);
115
116 auto extract_mesh_partition = [&](Mesh& global_mesh, Mesh& mesh) {
117 auto g_xy = array::make_view<double, 2>(global_mesh.nodes().xy());
118 auto g_lonlat = array::make_view<double, 2>(global_mesh.nodes().lonlat());
119 auto g_ghost = array::make_view<int, 1>(global_mesh.nodes().ghost());
120 auto g_gidx = array::make_view<gidx_t, 1>(global_mesh.nodes().global_index());
121 auto g_part = array::make_view<int,1>(global_mesh.nodes().partition());
122
123 size_t owned_nodes_count = dist.nb_pts()[part_];
124
125 std::vector<gidx_t> owned_nodes;
126 owned_nodes.reserve(1.4*owned_nodes_count);
127 for (size_t jnode=0; jnode < global_mesh.nodes().size(); ++ jnode) {
128 if (g_ghost(jnode) == 0) {
129 owned_nodes.emplace_back(jnode);
130 }
131 }
132 auto& g_node_connectivity = global_mesh.cells().node_connectivity();
133 std::set<idx_t> ghost_nodes;
134 std::vector<idx_t> owned_elements;
135 owned_elements.reserve(1.4*owned_nodes_count);
136 std::set<idx_t> element_nodes_uncertainty;
137 std::set<idx_t> element_uncertainty;
138 constexpr idx_t OWNED = -1;
139 constexpr idx_t GHOST = -2;
140 constexpr idx_t UNCERTAIN = -3;
141 constexpr idx_t CERTAIN = -4;
142
143 auto elem_node_partition = [&](idx_t jelem, idx_t jnode) -> int {
144 return g_part(g_node_connectivity(jelem,jnode));
145 };
146
147 auto get_elem_ownership = [&](idx_t jelem) -> int {
148 int p0 = elem_node_partition(jelem,0);
149 int p1 = elem_node_partition(jelem,1);
150 int p2 = elem_node_partition(jelem,2);
151 if (p0 != part_ && p1 != part_ && p2 != part_) {
152 return GHOST;
153 }
154 if ((p0 == p1 || p0 == p2) && p0 == part_) {
155 return OWNED;
156 }
157 else if (p1 == p2 && p1 == part_) {
158 return OWNED;
159 }
160 else if ( p0 == p1 || p0 == p2 || p1 == p2 ) {
161 return CERTAIN;
162 }
163 return UNCERTAIN;
164 };
165
166 auto get_elem_part = [&](idx_t jelem) -> int {
167 int p0 = elem_node_partition(jelem,0);
168 int p1 = elem_node_partition(jelem,1);
169 int p2 = elem_node_partition(jelem,2);
170 if (p0 == p1 || p0 == p2) {
171 return p0;
172 }
173 else if (p1 == p2) {
174 return p1;
175 }
176 return UNCERTAIN;
177 };
178
179
180 auto collect_element = [&](idx_t jelem){
181 owned_elements.emplace_back(jelem);
182 for (idx_t j=0; j<3; ++j) {
183 if (elem_node_partition(jelem,j) != part_) {
184 ghost_nodes.insert(g_node_connectivity(jelem,j));
185 }
186 }
187 };
188
189 for (idx_t jelem=0; jelem<global_mesh.cells().size(); ++jelem) {
190 idx_t elem_ownership = get_elem_ownership(jelem);
191 if (elem_ownership == OWNED) {
192 collect_element(jelem);
193 }
194 else if (elem_ownership == UNCERTAIN) {
195 // all three are different
196 element_nodes_uncertainty.insert(g_node_connectivity(jelem,0));
197 element_nodes_uncertainty.insert(g_node_connectivity(jelem,1));
198 element_nodes_uncertainty.insert(g_node_connectivity(jelem,2));
199 element_uncertainty.insert(jelem);
200 }
201 else if (elem_ownership != GHOST && elem_ownership != CERTAIN) {
202 ATLAS_NOTIMPLEMENTED;
203 }
204 }
205 // Log::info() << "element_uncertainty" << std::endl;
206 // for( auto& jelem: element_uncertainty ) {
207 // Log::info() << jelem << std::endl;
208 // }
209
210 if( element_uncertainty.size() ) {
211 std::map<idx_t,std::vector<idx_t>> node2element;
212 for (idx_t jelem=0; jelem<global_mesh.cells().size(); ++jelem) {
213 for (idx_t jj=0; jj<3; ++jj) {
214 idx_t n = g_node_connectivity(jelem,jj);
215 if (element_nodes_uncertainty.find(n) != element_nodes_uncertainty.end()) {
216 auto it = node2element.find(n);
217 if (it == node2element.end()) {
218 node2element[n].emplace_back(jelem);
219 }
220 else {
221 it->second.emplace_back(jelem);
222 }
223 }
224 }
225 }
226 // Log::info() << "node2element" << std::endl;
227 // for( auto& pair: node2element ) {
228 // idx_t jnode = pair.first;
229 // auto& elems = pair.second;
230 // // Log::info() << jnode << " : " << elems << std::endl;
231 // }
232
233 auto get_elem_edge = [&](idx_t jelem, idx_t jedge) {
234 if (jedge == 0) {
235 return std::array<idx_t,2>{
236 g_node_connectivity(jelem,0),
237 g_node_connectivity(jelem,1),
238 };
239 }
240 else if(jedge == 1) {
241 return std::array<idx_t,2>{
242 g_node_connectivity(jelem,1),
243 g_node_connectivity(jelem,2),
244 };
245 }
246 else if(jedge == 2) {
247 return std::array<idx_t,2>{
248 g_node_connectivity(jelem,2),
249 g_node_connectivity(jelem,0),
250 };
251 }
252 return std::array<idx_t,2>{-1,-1};
253 };
254
255 auto get_elem_neighbours = [&](idx_t jelem) -> std::array<idx_t,3> {
256 std::array<idx_t,3> elem_neighbours{-1,-1,-1};
257 idx_t jneighbour=0;
258 for (idx_t jedge=0; jedge<3; ++jedge) {
259 auto edge = get_elem_edge(jelem,jedge);
260 // Log::info() << "jelem,jedge " << jelem << "," << jedge << " : " << edge << " p: " << g_part(edge[0]) << " " << g_part(edge[1]) << std::endl;
261 auto& elem_candidates = node2element.at(edge[0]);
262 for (auto& ielem : elem_candidates) {
263 for (idx_t iedge=0; iedge<3; ++iedge) {
264 auto candidate_edge = get_elem_edge(ielem,iedge);
265 if ( edge[0] == candidate_edge[1] && edge[1] == candidate_edge[0] ) {
266 elem_neighbours[jneighbour++] = ielem;
267 goto next_neighbour;
268 }
269 }
270 }
271 next_neighbour:;
272 }
273 return elem_neighbours;
274 };
275
276 for( idx_t jelem : element_uncertainty ) {
277 auto elem_neighbours = get_elem_neighbours(jelem);
278 idx_t e0 = elem_neighbours[0] >= 0 ? get_elem_part(elem_neighbours[0]) : UNCERTAIN;
279 idx_t e1 = elem_neighbours[1] >= 0 ? get_elem_part(elem_neighbours[1]) : UNCERTAIN;
280 idx_t e2 = elem_neighbours[2] >= 0 ? get_elem_part(elem_neighbours[2]) : UNCERTAIN;
281
282 idx_t elem_part = UNCERTAIN;
283 if (e0 == e1 || e0 == e2) {
284 elem_part = e0;
285 }
286 else if (e1 == e2) {
287 elem_part = e1;
288 }
289 else if (e0 != UNCERTAIN) {
290 elem_part = e0;
291 }
292 else if (e1 != UNCERTAIN) {
293 elem_part = e1;
294 }
295 else if (e2 != UNCERTAIN) {
296 elem_part = e2;
297 }
298 if (elem_part == UNCERTAIN) {
299 elem_part = elem_node_partition(jelem,0);
300 }
301 if (elem_part == part_) {
302 collect_element(jelem);
303 }
304 }
305 }
306
307 size_t nb_nodes = owned_nodes.size() + ghost_nodes.size();
308
309 mesh.nodes().resize(nb_nodes);
310 auto xy = array::make_view<double, 2>(mesh.nodes().xy());
311 auto lonlat = array::make_view<double, 2>(mesh.nodes().lonlat());
312 auto ghost = array::make_view<int, 1>(mesh.nodes().ghost());
313 auto gidx = array::make_view<gidx_t, 1>(mesh.nodes().global_index());
314 auto part = array::make_view<int, 1>(mesh.nodes().partition());
315 auto halo = array::make_view<int, 1>(mesh.nodes().halo());
316 auto flags = array::make_view<int,1>(mesh.nodes().flags());
317 halo.assign(0.);
318 std::unordered_map<idx_t,idx_t> from_gnode;
319 for (idx_t jnode=0; jnode<owned_nodes.size(); ++jnode) {
320 // ATLAS_DEBUG_VAR(jnode);
321 idx_t gnode = owned_nodes[jnode];
322 from_gnode[gnode] = jnode;
323 // ATLAS_DEBUG_VAR(gnode);
324
325 xy(jnode,idx_t(XX)) = g_xy(gnode,idx_t(XX));
326 xy(jnode,idx_t(YY)) = g_xy(gnode,idx_t(YY));
327 lonlat(jnode,idx_t(XX)) = g_lonlat(gnode,idx_t(XX));
328 lonlat(jnode,idx_t(YY)) = g_lonlat(gnode,idx_t(YY));
329 ghost(jnode) = 0;
330 gidx(jnode) = g_gidx(gnode);
331 part(jnode) = part_;
332 util::Topology::view(flags(jnode)).reset(util::Topology::NONE);
333 }
334 idx_t jnode = owned_nodes.size();
335 for (idx_t gnode: ghost_nodes) {
336 ATLAS_ASSERT(jnode < nb_nodes);
337 from_gnode[gnode] = jnode;
338 xy(jnode,idx_t(XX)) = g_xy(gnode,idx_t(XX));
339 xy(jnode,idx_t(YY)) = g_xy(gnode,idx_t(YY));
340 lonlat(jnode,idx_t(XX)) = g_lonlat(gnode,idx_t(XX));
341 lonlat(jnode,idx_t(YY)) = g_lonlat(gnode,idx_t(YY));
342 ghost(jnode) = 1;
343 gidx(jnode) = g_gidx(gnode);
344 part(jnode) = g_part(gnode);
345 util::Topology::view(flags(jnode)).reset(util::Topology::GHOST);
346 ++jnode;
347 }
348
349
350 mesh.cells().add(mesh::ElementType::create("Triangle"), owned_elements.size());
351 auto& node_connectivity = mesh.cells().node_connectivity();
352 auto cell_gidx = array::make_view<gidx_t, 1>(mesh.cells().global_index());
353 auto cell_part = array::make_view<int, 1>(mesh.cells().partition());
354
355 for (idx_t jelem=0; jelem<owned_elements.size(); ++jelem) {
356 idx_t gelem = owned_elements[jelem];
357 std::array<idx_t,3> triag_nodes {
358 from_gnode[g_node_connectivity(gelem,0)],
359 from_gnode[g_node_connectivity(gelem,1)],
360 from_gnode[g_node_connectivity(gelem,2)]
361 };
362 node_connectivity.set(jelem, triag_nodes.data());
363 cell_gidx(jelem) = gelem+1;
364 cell_part(jelem) = part_;
365 }
366 };
367
368 extract_mesh_partition(global_mesh, mesh);
369
370 setGrid(mesh, grid, dist.type());
371 mesh.metadata().set("mpi_comm",mpi_comm_);
372 }
373
374 void DelaunayMeshGenerator::generate(const Grid& g, Mesh& mesh) const {
375 mpi::Scope mpi_scope(mpi_comm_);
376 generate( g, grid::Distribution{g,g.partitioner()}, mesh);
377 }
378
379 namespace {
380 static MeshGeneratorBuilder<DelaunayMeshGenerator> __delaunay("delaunay");
381 }
382
383 //----------------------------------------------------------------------------------------------------------------------
384
385 } // namespace meshgenerator
386 } // namespace atlas