Debian Codegraph @

src/atlas/mesh/actions/BuildDualMesh.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 <algorithm>
12 #include <cmath>
13 #include <iostream>
14 #include <limits>
15 #include <set>
16 #include <stdexcept>
17
18 #include "atlas/array/ArrayView.h"
19 #include "atlas/array/IndexView.h"
20 #include "atlas/field/Field.h"
21 #include "atlas/functionspace/EdgeColumns.h"
22 #include "atlas/functionspace/NodeColumns.h"
23 #include "atlas/grid/StructuredGrid.h"
24 #include "atlas/library/config.h"
25 #include "atlas/mesh/HybridElements.h"
26 #include "atlas/mesh/Mesh.h"
27 #include "atlas/mesh/Nodes.h"
28 #include "atlas/mesh/actions/BuildDualMesh.h"
29 #include "atlas/parallel/Checksum.h"
30 #include "atlas/runtime/Exception.h"
31 #include "atlas/runtime/Trace.h"
32 #include "atlas/util/CoordinateEnums.h"
33 #include "atlas/util/Unique.h"
34
35 using atlas::functionspace::NodeColumns;
36 using atlas::mesh::Halo;
37
38 namespace atlas {
39 namespace mesh {
40 namespace actions {
41
42 namespace {
43
44 void global_bounding_box(const mesh::Nodes& nodes, double min[2], double max[2]) {
45 ATLAS_TRACE();
46
47 auto xy = array::make_view<double, 2>(nodes.xy());
48 const int nb_nodes = nodes.size();
49 min[XX] = std::numeric_limits<double>::max();
50 min[YY] = std::numeric_limits<double>::max();
51 max[XX] = -std::numeric_limits<double>::max();
52 max[YY] = -std::numeric_limits<double>::max();
53
54 for (int node = 0; node < nb_nodes; ++node) {
55 min[XX] = std::min(min[XX], xy(node, XX));
56 min[YY] = std::min(min[YY], xy(node, YY));
57 max[XX] = std::max(max[XX], xy(node, XX));
58 max[YY] = std::max(max[YY], xy(node, YY));
59 }
60
61 ATLAS_TRACE_MPI(ALLREDUCE) {
62 mpi::comm().allReduceInPlace(min, 2, eckit::mpi::min());
63 mpi::comm().allReduceInPlace(max, 2, eckit::mpi::max());
64 }
65 }
66
67 struct Node {
68 Node() = default;
69 Node(gidx_t gid, idx_t idx) {
70 g = gid;
71 i = idx;
72 }
73 gidx_t g;
74 idx_t i;
75
76 bool operator<(const Node& other) const { return (g < other.g); }
77 };
78
79 } // namespace
80
81 array::Array* build_centroids_xy(const mesh::HybridElements&, const Field& xy);
82
83 void add_centroid_dual_volume_contribution(Mesh& mesh, array::ArrayView<double, 1>& dual_volumes);
84 void add_median_dual_volume_contribution_cells(const mesh::HybridElements& cells, const mesh::HybridElements& edges,
85 const mesh::Nodes& nodes, array::Array& array_dual_volumes);
86 void add_median_dual_volume_contribution_poles(const mesh::HybridElements& edges, const mesh::Nodes& nodes,
87 array::Array& array_dual_volumes);
88 void build_dual_normals(Mesh& mesh);
89 void make_dual_normals_outward(Mesh& mesh);
90
91 void build_median_dual_mesh(Mesh& mesh) {
92 ATLAS_TRACE();
93 bool median_dual_mesh = false;
94 mesh.metadata().get("median_dual_mesh", median_dual_mesh);
95 if (median_dual_mesh) {
96 return;
97 }
98 mesh.metadata().set("median_dual_mesh", true);
99
100 mesh::Nodes& nodes = mesh.nodes();
101 mesh::HybridElements& edges = mesh.edges();
102 Field dual_volumes =
103 nodes.add(Field("dual_volumes", array::make_datatype<double>(), array::make_shape(nodes.size())));
104
105 if (!mesh.cells().has_field("centroids_xy")) {
106 mesh.cells().add(Field("centroids_xy", build_centroids_xy(mesh.cells(), mesh.nodes().xy())));
107 }
108
109 if (!mesh.edges().has_field("centroids_xy")) {
110 mesh.edges().add(Field("centroids_xy", build_centroids_xy(mesh.edges(), mesh.nodes().xy())));
111 }
112
113 array::ArrayView<double, 1> v = array::make_view<double, 1>(dual_volumes);
114 v.assign(0.);
115 add_median_dual_volume_contribution_cells(mesh.cells(), mesh.edges(), mesh.nodes(), dual_volumes);
116 add_median_dual_volume_contribution_poles(mesh.edges(), mesh.nodes(), dual_volumes);
117
118 build_dual_normals(mesh);
119
120 Field skewness =
121 mesh.edges().add(Field("skewness", array::make_datatype<double>(), array::make_shape(mesh.edges().size())));
122 Field alpha =
123 mesh.edges().add(Field("alpha", array::make_datatype<double>(), array::make_shape(mesh.edges().size())));
124 array::make_view<double, 1>(skewness).assign(0.);
125 array::make_view<double, 1>(alpha).assign(0.5);
126
127 functionspace::NodeColumns nodes_fs(mesh);
128 {
129 ATLAS_TRACE("halo-exchange dual_volumes");
130 nodes_fs.haloExchange(nodes.field("dual_volumes"));
131 }
132
133 functionspace::EdgeColumns edges_fs(mesh);
134 {
135 ATLAS_TRACE("halo-exchange dual_normals");
136 edges_fs.haloExchange(edges.field("dual_normals"));
137 }
138 make_dual_normals_outward(mesh);
139 }
140
141 array::Array* build_centroids_xy(const mesh::HybridElements& elements, const Field& field_xy) {
142 auto xy = array::make_view<double, 2>(field_xy);
143 array::Array* array_centroids = array::Array::create<double>(array::make_shape(elements.size(), 2));
144 array::ArrayView<double, 2> centroids = array::make_view<double, 2>(*array_centroids);
145 idx_t nb_elems = elements.size();
146 const mesh::HybridElements::Connectivity& elem_nodes = elements.node_connectivity();
147 for (idx_t e = 0; e < nb_elems; ++e) {
148 centroids(e, XX) = 0.;
149 centroids(e, YY) = 0.;
150 const idx_t nb_nodes_per_elem = elem_nodes.cols(e);
151 const double average_coefficient = 1. / static_cast<double>(nb_nodes_per_elem);
152 for (idx_t n = 0; n < nb_nodes_per_elem; ++n) {
153 centroids(e, XX) += xy(elem_nodes(e, n), XX);
154 centroids(e, YY) += xy(elem_nodes(e, n), YY);
155 }
156 centroids(e, XX) *= average_coefficient;
157 centroids(e, YY) *= average_coefficient;
158 }
159 return array_centroids;
160 }
161
162 void add_median_dual_volume_contribution_cells(const mesh::HybridElements& cells, const mesh::HybridElements& edges,
163 const mesh::Nodes& nodes, array::Array& array_dual_volumes) {
164 ATLAS_TRACE();
165
166 auto dual_volumes = array::make_view<double, 1>(array_dual_volumes);
167
168 auto xy = array::make_view<double, 2>(nodes.xy());
169 auto cell_centroids = array::make_view<double, 2>(cells.field("centroids_xy"));
170 auto edge_centroids = array::make_view<double, 2>(edges.field("centroids_xy"));
171 const mesh::HybridElements::Connectivity& cell_edge_connectivity = cells.edge_connectivity();
172 const mesh::HybridElements::Connectivity& edge_node_connectivity = edges.node_connectivity();
173 auto field_flags = array::make_view<int, 1>(cells.flags());
174
175 auto patch = [&field_flags](idx_t e) {
176 using Topology = atlas::mesh::Nodes::Topology;
177 return Topology::check(field_flags(e), Topology::PATCH);
178 };
179
180 // special ordering for bit-identical results
181 idx_t nb_cells = cells.size();
182 std::vector<Node> ordering(nb_cells);
183 for (idx_t jcell = 0; jcell < nb_cells; ++jcell) {
184 ordering[jcell] = Node(util::unique_lonlat(cell_centroids(jcell, XX), cell_centroids(jcell, YY)), jcell);
185 }
186 std::sort(ordering.data(), ordering.data() + nb_cells);
187
188 for (idx_t jcell = 0; jcell < nb_cells; ++jcell) {
189 idx_t icell = ordering[jcell].i;
190 if (patch(icell)) {
191 continue;
192 }
193 double x0 = cell_centroids(icell, XX);
194 double y0 = cell_centroids(icell, YY);
195
196 for (idx_t jedge = 0; jedge < cell_edge_connectivity.cols(icell); ++jedge) {
197 idx_t iedge = cell_edge_connectivity(icell, jedge);
198 double x1 = edge_centroids(iedge, XX);
199 double y1 = edge_centroids(iedge, YY);
200 for (idx_t jnode = 0; jnode < 2; ++jnode) {
201 idx_t inode = edge_node_connectivity(iedge, jnode);
202 double x2 = xy(inode, XX);
203 double y2 = xy(inode, YY);
204 double triag_area = std::abs(x0 * (y1 - y2) + x1 * (y2 - y0) + x2 * (y0 - y1)) * 0.5;
205 dual_volumes(inode) += triag_area;
206 }
207 }
208 }
209 }
210
211 void add_median_dual_volume_contribution_poles(const mesh::HybridElements& edges, const mesh::Nodes& nodes,
212 array::Array& array_dual_volumes) {
213 ATLAS_TRACE();
214
215 array::ArrayView<double, 1> dual_volumes = array::make_view<double, 1>(array_dual_volumes);
216 auto xy = array::make_view<double, 2>(nodes.xy());
217 auto edge_centroids = array::make_view<double, 2>(edges.field("centroids_xy"));
218 const mesh::HybridElements::Connectivity& edge_node_connectivity = edges.node_connectivity();
219 const mesh::HybridElements::Connectivity& edge_cell_connectivity = edges.cell_connectivity();
220
221 const idx_t nb_edges = edges.size();
222 std::map<idx_t, std::vector<idx_t>> node_to_bdry_edge;
223 for (idx_t jedge = 0; jedge < nb_edges; ++jedge) {
224 if (edge_cell_connectivity(jedge, 0) != edge_cell_connectivity.missing_value() &&
225 edge_cell_connectivity(jedge, 1) == edge_cell_connectivity.missing_value()) {
226 node_to_bdry_edge[edge_node_connectivity(jedge, 0)].push_back(jedge);
227 node_to_bdry_edge[edge_node_connectivity(jedge, 1)].push_back(jedge);
228 }
229 }
230
231 const double tol = 1.e-6;
232 double min[2], max[2];
233 global_bounding_box(nodes, min, max);
234
235 std::map<idx_t, std::vector<idx_t>>::iterator it;
236 for (it = node_to_bdry_edge.begin(); it != node_to_bdry_edge.end(); ++it) {
237 const idx_t jnode = (*it).first;
238 std::vector<idx_t>& bdry_edges = (*it).second;
239 const double x0 = xy(jnode, XX);
240 const double y0 = xy(jnode, YY);
241 double x1, y1, y2;
242 for (idx_t jedge = 0; jedge < static_cast<idx_t>(bdry_edges.size()); ++jedge) {
243 const idx_t iedge = bdry_edges[jedge];
244 x1 = edge_centroids(iedge, XX);
245 y1 = edge_centroids(iedge, YY);
246
247 y2 = 0.;
248 if (std::abs(y1 - max[YY]) < tol) {
249 y2 = 90.;
250 }
251 else if (std::abs(y1 - min[YY]) < tol) {
252 y2 = -90.;
253 }
254
255 if (y2 != 0) {
256 const double quad_area = std::abs((x1 - x0) * (y2 - y0));
257 dual_volumes(jnode) += quad_area;
258 }
259 }
260 }
261 }
262
263 void build_dual_normals(Mesh& mesh) {
264 ATLAS_TRACE();
265
266 array::ArrayView<double, 2> elem_centroids = array::make_view<double, 2>(mesh.cells().field("centroids_xy"));
267
268 mesh::Nodes& nodes = mesh.nodes();
269 mesh::HybridElements& edges = mesh.edges();
270 const idx_t nb_edges = edges.size();
271
272 array::ArrayView<double, 2> node_xy = array::make_view<double, 2>(nodes.xy());
273 double min[2], max[2];
274 global_bounding_box(nodes, min, max);
275 double tol = 1.e-6;
276
277 double xl, yl, xr, yr;
278 array::ArrayView<double, 2> edge_centroids = array::make_view<double, 2>(edges.field("centroids_xy"));
279 array::ArrayView<double, 2> dual_normals = array::make_view<double, 2>(
280 edges.add(Field("dual_normals", array::make_datatype<double>(), array::make_shape(nb_edges, 2))));
281
282 const mesh::HybridElements::Connectivity& edge_node_connectivity = edges.node_connectivity();
283 const mesh::HybridElements::Connectivity& edge_cell_connectivity = edges.cell_connectivity();
284
285 std::map<idx_t, std::vector<idx_t>> node_to_bdry_edge;
286 for (idx_t jedge = 0; jedge < nb_edges; ++jedge) {
287 if (edge_cell_connectivity(jedge, 0) != edge_cell_connectivity.missing_value() &&
288 edge_cell_connectivity(jedge, 1) == edge_cell_connectivity.missing_value()) {
289 node_to_bdry_edge[edge_node_connectivity(jedge, 0)].push_back(jedge);
290 node_to_bdry_edge[edge_node_connectivity(jedge, 1)].push_back(jedge);
291 }
292 }
293
294 for (idx_t edge = 0; edge < nb_edges; ++edge) {
295 if (edge_cell_connectivity(edge, 0) == edge_cell_connectivity.missing_value()) {
296 // this is a pole edge
297 // only compute for one node
298 for (idx_t n = 0; n < 2; ++n) {
299 idx_t node = edge_node_connectivity(edge, n);
300 std::vector<idx_t>& bdry_edges = node_to_bdry_edge[node];
301 double x[2];
302 idx_t cnt = 0;
303 const idx_t nb_bdry_edges = static_cast<idx_t>(bdry_edges.size());
304 for (idx_t jedge = 0; jedge < nb_bdry_edges; ++jedge) {
305 idx_t bdry_edge = bdry_edges[jedge];
306 if (std::abs(edge_centroids(bdry_edge, YY) - max[YY]) < tol) {
307 edge_centroids(edge, YY) = 90.;
308 x[cnt] = edge_centroids(bdry_edge, XX);
309 ++cnt;
310 }
311 else if (std::abs(edge_centroids(bdry_edge, YY) - min[YY]) < tol) {
312 edge_centroids(edge, YY) = -90.;
313 x[cnt] = edge_centroids(bdry_edge, XX);
314 ++cnt;
315 }
316 }
317 if (cnt == 2) {
318 dual_normals(edge, XX) = 0;
319 if (node_xy(node, YY) < 0.) {
320 dual_normals(edge, YY) = -std::abs(x[1] - x[0]);
321 }
322 else if (node_xy(node, YY) > 0.) {
323 dual_normals(edge, YY) = std::abs(x[1] - x[0]);
324 }
325
326 // std::cout << "pole dual_normal = " << dual_normals(YY,edge) <<
327 // std::endl;
328 break;
329 }
330 }
331 }
332 else {
333 idx_t left_elem = edge_cell_connectivity(edge, 0);
334 idx_t right_elem = edge_cell_connectivity(edge, 1);
335 xl = elem_centroids(left_elem, XX);
336 yl = elem_centroids(left_elem, YY);
337 if (right_elem == edge_cell_connectivity.missing_value()) {
338 xr = edge_centroids(edge, XX);
339 yr = edge_centroids(edge, YY);
340 ;
341 if (std::abs(yr - max[YY]) < tol) {
342 yr = 90.;
343 }
344 else if (std::abs(yr - min[YY]) < tol) {
345 yr = -90.;
346 }
347 }
348 else {
349 xr = elem_centroids(right_elem, XX);
350 yr = elem_centroids(right_elem, YY);
351 }
352
353 dual_normals(edge, XX) = yl - yr;
354 dual_normals(edge, YY) = -xl + xr;
355 }
356 }
357 }
358
359 void make_dual_normals_outward(Mesh& mesh) {
360 ATLAS_TRACE();
361 mesh::Nodes& nodes = mesh.nodes();
362 array::ArrayView<double, 2> node_xy = array::make_view<double, 2>(nodes.xy());
363
364 mesh::HybridElements& edges = mesh.edges();
365 const mesh::HybridElements::Connectivity& edge_cell_connectivity = edges.cell_connectivity();
366 const mesh::HybridElements::Connectivity& edge_node_connectivity = edges.node_connectivity();
367 array::ArrayView<double, 2> dual_normals = array::make_view<double, 2>(edges.field("dual_normals"));
368 const idx_t nb_edges = edges.size();
369
370 for (idx_t edge = 0; edge < nb_edges; ++edge) {
371 if (edge_cell_connectivity(edge, 0) != edge_cell_connectivity.missing_value()) {
372 // Make normal point from node 1 to node 2
373 const idx_t ip1 = edge_node_connectivity(edge, 0);
374 const idx_t ip2 = edge_node_connectivity(edge, 1);
375 double dx = node_xy(ip2, XX) - node_xy(ip1, XX);
376 double dy = node_xy(ip2, YY) - node_xy(ip1, YY);
377 if (dx * dual_normals(edge, XX) + dy * dual_normals(edge, YY) < 0) {
378 dual_normals(edge, XX) = -dual_normals(edge, XX);
379 dual_normals(edge, YY) = -dual_normals(edge, YY);
380 }
381 }
382 }
383 }
384
385 void build_brick_dual_mesh(const Grid& grid, Mesh& mesh) {
386 auto g = StructuredGrid(grid);
387 if (g) {
388 if (mpi::size() != 1) {
389 throw_Exception("Cannot build_brick_dual_mesh with more than 1 task", Here());
390 }
391
392 mesh::Nodes& nodes = mesh.nodes();
393 auto xy = array::make_view<double, 2>(nodes.xy());
394 auto dual_volumes = array::make_view<double, 1>(
395 nodes.add(Field("dual_volumes", array::make_datatype<double>(), array::make_shape(nodes.size()))));
396 auto gidx = array::make_view<gidx_t, 1>(nodes.global_index());
397
398 int c = 0;
399 int n = 0;
400 for (idx_t jlat = 0; jlat < g.ny(); ++jlat) {
401 double lat = g.y(jlat);
402 double latN = (jlat == 0) ? 90. : 0.5 * (lat + g.y(jlat - 1));
403 double latS = (jlat == g.ny() - 1) ? -90. : 0.5 * (lat + g.y(jlat + 1));
404 double dlat = (latN - latS);
405 double dlon = 360. / static_cast<double>(g.nx(jlat));
406
407 for (idx_t jlon = 0; jlon < g.nx(jlat); ++jlon) {
408 while (gidx(c) != n + 1) {
409 c++;
410 }
411 ATLAS_ASSERT(xy(c, XX) == g.x(jlon, jlat));
412 ATLAS_ASSERT(xy(c, YY) == lat);
413 dual_volumes(c) = dlon * dlat;
414 ++n;
415 }
416 }
417
418 functionspace::NodeColumns nodes_fs(mesh);
419 nodes_fs.haloExchange(nodes.field("dual_volumes"));
420 }
421 else {
422 throw_Exception("Cannot build_brick_dual_mesh with mesh provided grid type", Here());
423 }
424 }
425
426 void build_centroid_dual_mesh(Mesh&) {
427 ATLAS_NOTIMPLEMENTED;
428 // This requires code below which has not been ported yet
429 }
430
431 // ------------------------------------------------------------------
432 // C wrapper interfaces to C++ routines
433
434 void atlas__build_median_dual_mesh(Mesh::Implementation* mesh) {
435 ATLAS_ASSERT(mesh != nullptr, "Cannot access uninitialised atlas_Mesh");
436 Mesh m(mesh);
437 build_median_dual_mesh(m);
438 }
439
440 void atlas__build_centroid_dual_mesh(Mesh::Implementation* mesh) {
441 ATLAS_ASSERT(mesh != nullptr, "Cannot access uninitialised atlas_Mesh");
442 Mesh m(mesh);
443 build_centroid_dual_mesh(m);
444 }
445 // ------------------------------------------------------------------
446
447 } // namespace actions
448 } // namespace mesh
449 } // namespace atlas