Debian Codegraph @

src/atlas/mesh/detail/AccumulateFacets.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 "atlas/mesh/detail/AccumulateFacets.h"
12 #include "atlas/mesh/Elements.h"
13 #include "atlas/mesh/HybridElements.h"
14 #include "atlas/mesh/Nodes.h"
15 #include "atlas/runtime/Exception.h"
16 #include "atlas/runtime/Trace.h"
17
18 namespace atlas {
19 namespace mesh {
20 namespace detail {
21
22 void accumulate_facets(const mesh::HybridElements& cells, const mesh::Nodes& nodes,
23 std::vector<idx_t>& facet_nodes_data, // shape(nb_facets,nb_nodes_per_facet)
24 std::vector<idx_t>& connectivity_facet_to_elem, idx_t& nb_facets, idx_t& nb_inner_facets,
25 idx_t& missing_value) {
26 ATLAS_TRACE();
27 missing_value = -1;
28 std::vector<std::vector<idx_t>> node_to_facet(nodes.size());
29 for (auto& facet : node_to_facet) {
30 facet.reserve(6);
31 }
32 nb_facets = 0;
33 nb_inner_facets = 0;
34 if (connectivity_facet_to_elem.size() == 0) {
35 connectivity_facet_to_elem.reserve(6 * cells.size());
36 }
37 if (facet_nodes_data.size() == 0) {
38 facet_nodes_data.reserve(6 * cells.size());
39 }
40 for (idx_t t = 0; t < cells.nb_types(); ++t) {
41 const mesh::Elements& elements = cells.elements(t);
42 const mesh::BlockConnectivity& elem_nodes = elements.node_connectivity();
43 auto elem_flags = elements.view<int, 1>(elements.flags());
44
45 auto patch = [&elem_flags](idx_t e) {
46 using Topology = atlas::mesh::Nodes::Topology;
47 return Topology::check(elem_flags(e), Topology::PATCH);
48 };
49
50 idx_t nb_elems = elements.size();
51 idx_t nb_nodes_in_facet = 2;
52
53 std::vector<std::vector<int>> facet_node_numbering;
54 idx_t nb_facets_in_elem;
55 if (elements.name() == "Pentagon") {
56 nb_facets_in_elem = 5;
57 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
58 facet_node_numbering[0][0] = 0;
59 facet_node_numbering[0][1] = 1;
60 facet_node_numbering[1][0] = 1;
61 facet_node_numbering[1][1] = 2;
62 facet_node_numbering[2][0] = 2;
63 facet_node_numbering[2][1] = 3;
64 facet_node_numbering[3][0] = 3;
65 facet_node_numbering[3][1] = 4;
66 facet_node_numbering[4][0] = 4;
67 facet_node_numbering[4][1] = 0;
68 }
69 else if (elements.name() == "Quadrilateral") {
70 nb_facets_in_elem = 4;
71 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
72 facet_node_numbering[0][0] = 0;
73 facet_node_numbering[0][1] = 1;
74 facet_node_numbering[1][0] = 1;
75 facet_node_numbering[1][1] = 2;
76 facet_node_numbering[2][0] = 2;
77 facet_node_numbering[2][1] = 3;
78 facet_node_numbering[3][0] = 3;
79 facet_node_numbering[3][1] = 0;
80 }
81 else if (elements.name() == "Triangle") {
82 nb_facets_in_elem = 3;
83 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
84 facet_node_numbering[0][0] = 0;
85 facet_node_numbering[0][1] = 1;
86 facet_node_numbering[1][0] = 1;
87 facet_node_numbering[1][1] = 2;
88 facet_node_numbering[2][0] = 2;
89 facet_node_numbering[2][1] = 0;
90 }
91 else {
92 throw_Exception(elements.name() + " is not \"Pentagon\", \"Quadrilateral\", or \"Triangle\"", Here());
93 }
94
95 std::vector<idx_t> facet_nodes(nb_nodes_in_facet);
96
97 for (idx_t e = 0; e < nb_elems; ++e) {
98 if (patch(e)) {
99 continue;
100 }
101 for (idx_t f = 0; f < nb_facets_in_elem; ++f) {
102 bool found_face = false;
103
104 for (idx_t jnode = 0; jnode < nb_nodes_in_facet; ++jnode) {
105 facet_nodes[jnode] = elem_nodes(e, facet_node_numbering[f][jnode]);
106 }
107
108 idx_t node = facet_nodes[0];
109 for (const idx_t face : node_to_facet[node]) {
110 idx_t nb_matched_nodes = 0;
111 if (nb_nodes_in_facet > 1) // 2D or 3D
112 {
113 for (idx_t jnode = 0; jnode < nb_nodes_in_facet; ++jnode) {
114 idx_t other_node = facet_nodes[jnode];
115 for (const idx_t other_face : node_to_facet[other_node]) {
116 if (other_face == face) {
117 ++nb_matched_nodes;
118 break;
119 }
120 }
121 }
122 if (nb_matched_nodes == nb_nodes_in_facet) {
123 connectivity_facet_to_elem[2 * face + 1] = e + elements.begin();
124 ++nb_inner_facets;
125 found_face = true;
126 break;
127 }
128 }
129 }
130
131 if (found_face == false) {
132 connectivity_facet_to_elem.emplace_back(elements.begin() + e);
133 // if 2nd element stays missing_value, it is a bdry face
134 connectivity_facet_to_elem.emplace_back(missing_value);
135 for (idx_t n = 0; n < nb_nodes_in_facet; ++n) {
136 node_to_facet[facet_nodes[n]].emplace_back(nb_facets);
137 facet_nodes_data.emplace_back(facet_nodes[n]);
138 }
139 ++nb_facets;
140 }
141 }
142 }
143 }
144 }
145
146 void accumulate_facets_in_range(std::vector<array::Range>& range, const mesh::HybridElements& cells,
147 const mesh::Nodes& /*nodes*/,
148 std::vector<idx_t>& facet_nodes_data, // shape(nb_facets,nb_nodes_per_facet)
149 std::vector<idx_t>& connectivity_facet_to_elem, idx_t& nb_facets,
150 idx_t& nb_inner_facets, idx_t& missing_value,
151 std::vector<std::vector<idx_t>>& node_to_facet) {
152 ATLAS_TRACE();
153 if (connectivity_facet_to_elem.size() == 0) {
154 connectivity_facet_to_elem.reserve(6 * cells.size());
155 }
156 if (facet_nodes_data.size() == 0) {
157 facet_nodes_data.reserve(6 * cells.size());
158 }
159 for (idx_t t = 0; t < cells.nb_types(); ++t) {
160 const mesh::Elements& elements = cells.elements(t);
161 const mesh::BlockConnectivity& elem_nodes = elements.node_connectivity();
162 auto elem_flags = elements.view<int, 1>(elements.flags());
163
164 auto patch = [&elem_flags](idx_t e) {
165 using Topology = atlas::mesh::Nodes::Topology;
166 return Topology::check(elem_flags(e), Topology::PATCH);
167 };
168
169 idx_t nb_nodes_in_facet = 2;
170
171 std::vector<std::vector<int>> facet_node_numbering;
172 idx_t nb_facets_in_elem;
173 if (elements.name() == "Pentagon") {
174 nb_facets_in_elem = 5;
175 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
176 facet_node_numbering[0][0] = 0;
177 facet_node_numbering[0][1] = 1;
178 facet_node_numbering[1][0] = 1;
179 facet_node_numbering[1][1] = 2;
180 facet_node_numbering[2][0] = 2;
181 facet_node_numbering[2][1] = 3;
182 facet_node_numbering[3][0] = 3;
183 facet_node_numbering[3][1] = 4;
184 facet_node_numbering[4][0] = 4;
185 facet_node_numbering[4][1] = 0;
186 }
187 else if (elements.name() == "Quadrilateral") {
188 nb_facets_in_elem = 4;
189 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
190 facet_node_numbering[0][0] = 0;
191 facet_node_numbering[0][1] = 1;
192 facet_node_numbering[1][0] = 1;
193 facet_node_numbering[1][1] = 2;
194 facet_node_numbering[2][0] = 2;
195 facet_node_numbering[2][1] = 3;
196 facet_node_numbering[3][0] = 3;
197 facet_node_numbering[3][1] = 0;
198 }
199 else if (elements.name() == "Triangle") {
200 nb_facets_in_elem = 3;
201 facet_node_numbering.resize(nb_facets_in_elem, std::vector<int>(nb_nodes_in_facet));
202 facet_node_numbering[0][0] = 0;
203 facet_node_numbering[0][1] = 1;
204 facet_node_numbering[1][0] = 1;
205 facet_node_numbering[1][1] = 2;
206 facet_node_numbering[2][0] = 2;
207 facet_node_numbering[2][1] = 0;
208 }
209 else {
210 throw_Exception(elements.name() + " is not \"Pentagon\", \"Quadrilateral\", or \"Triangle\"", Here());
211 }
212
213 std::vector<idx_t> facet_nodes(nb_nodes_in_facet);
214
215 const idx_t e_start = range[t].start();
216 const idx_t e_end = range[t].end();
217
218 for (idx_t e = e_start; e < e_end; ++e) {
219 if (patch(e)) {
220 continue;
221 }
222
223 for (idx_t f = 0; f < nb_facets_in_elem; ++f) {
224 bool found_face = false;
225
226 for (idx_t jnode = 0; jnode < nb_nodes_in_facet; ++jnode) {
227 facet_nodes[jnode] = elem_nodes(e, facet_node_numbering[f][jnode]);
228 }
229
230 int node = facet_nodes[0];
231 for (idx_t face : node_to_facet[node]) {
232 idx_t nb_matched_nodes = 0;
233 if (nb_nodes_in_facet > 1) // 2D or 3D
234 {
235 for (idx_t jnode = 0; jnode < nb_nodes_in_facet; ++jnode) {
236 idx_t other_node = facet_nodes[jnode];
237 for (idx_t other_face : node_to_facet[other_node]) {
238 if (other_face == face) {
239 ++nb_matched_nodes;
240 break;
241 }
242 }
243 }
244 if (nb_matched_nodes == nb_nodes_in_facet) {
245 connectivity_facet_to_elem[2 * face + 1] = e + elements.begin();
246 ++nb_inner_facets;
247 found_face = true;
248 break;
249 }
250 }
251 }
252
253 if (found_face == false) {
254 connectivity_facet_to_elem.emplace_back(elements.begin() + e);
255 // if 2nd element stays missing_value, it is a bdry face
256 connectivity_facet_to_elem.emplace_back(missing_value);
257 for (idx_t n = 0; n < nb_nodes_in_facet; ++n) {
258 node_to_facet[facet_nodes[n]].emplace_back(nb_facets);
259 facet_nodes_data.emplace_back(facet_nodes[n]);
260 }
261 ++nb_facets;
262 }
263 }
264 }
265 }
266 }
267
268 void accumulate_facets_ordered_by_halo(const mesh::HybridElements& cells, const mesh::Nodes& nodes,
269 std::vector<idx_t>& facet_nodes_data, // shape(nb_facets,nb_nodes_per_facet)
270 std::vector<idx_t>& connectivity_facet_to_elem, idx_t& nb_facets,
271 idx_t& nb_inner_facets, idx_t& missing_value, std::vector<idx_t>& halo_offsets) {
272 ATLAS_TRACE();
273
274 static int MAXHALO = 50;
275 std::vector<std::vector<array::Range>> ranges(MAXHALO, std::vector<array::Range>(cells.nb_types()));
276
277 int maxhalo{0};
278 for (idx_t t = 0; t < cells.nb_types(); ++t) {
279 const mesh::Elements& elements = cells.elements(t);
280 auto elem_halo = elements.view<int, 1>(elements.halo());
281 idx_t nb_elems = elements.size();
282
283 int halo{0};
284 int begin{0};
285 int end{0};
286 for (idx_t e = 0; e < nb_elems; ++e) {
287 ATLAS_ASSERT(elem_halo(e) >= halo);
288 if (elem_halo(e) > halo) {
289 end = e;
290 ranges[halo][t] = array::Range{begin, end};
291 begin = end;
292 ++halo;
293 }
294 }
295 end = nb_elems;
296 ranges[halo][t] = array::Range{begin, end};
297 maxhalo = std::max(halo, maxhalo);
298 }
299
300
301 missing_value = -1;
302 std::vector<std::vector<idx_t>> node_to_facet(nodes.size());
303 for (auto& facets : node_to_facet) {
304 facets.reserve(6);
305 }
306 nb_facets = 0;
307 nb_inner_facets = 0;
308
309
310 halo_offsets = std::vector<idx_t>{0};
311 for (int h = 0; h <= maxhalo; ++h) {
312 accumulate_facets_in_range(ranges[h], cells, nodes, facet_nodes_data, connectivity_facet_to_elem, nb_facets,
313 nb_inner_facets, missing_value, node_to_facet);
314 halo_offsets.emplace_back(nb_facets);
315 }
316 }
317
318
319 } // namespace detail
320 } // namespace mesh
321 } // namespace atlas