Debian Codegraph @

src/atlas/functionspace/detail/NodeColumnsInterface.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 <cstring>
12
13 #include "NodeColumnsInterface.h"
14 #include "atlas/field/FieldSet.h"
15 #include "atlas/field/detail/FieldImpl.h"
16 #include "atlas/runtime/Exception.h"
17
18 namespace atlas {
19 namespace functionspace {
20 namespace detail {
21
22 using atlas::FieldSet;
23 using atlas::field::FieldImpl;
24 using atlas::field::FieldSetImpl;
25
26 // ----------------------------------------------------------------------
27
28 extern "C" {
29 const NodeColumns* atlas__NodesFunctionSpace__new(Mesh::Implementation* mesh, const eckit::Configuration* config) {
30 ATLAS_ASSERT(mesh);
31 Mesh m(mesh);
32 return new NodeColumns(m, *config);
33 }
34
35 void atlas__NodesFunctionSpace__delete(NodeColumns* This) {
36 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
37 delete (This);
38 }
39
40 int atlas__NodesFunctionSpace__nb_nodes(const NodeColumns* This) {
41 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
42 return This->nb_nodes();
43 }
44
45 const Mesh::Implementation* atlas__NodesFunctionSpace__mesh(const NodeColumns* This) {
46 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
47 return This->mesh().get();
48 }
49
50 mesh::Nodes* atlas__NodesFunctionSpace__nodes(const NodeColumns* This) {
51 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
52 return &This->nodes();
53 }
54
55 void atlas__NodesFunctionSpace__halo_exchange_fieldset(const NodeColumns* This, field::FieldSetImpl* fieldset) {
56 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
57 ATLAS_ASSERT(fieldset != nullptr, "Cannot access uninitialised atlas_FieldSet");
58 FieldSet f(fieldset);
59 This->haloExchange(f);
60 }
61
62 void atlas__NodesFunctionSpace__halo_exchange_field(const NodeColumns* This, field::FieldImpl* field) {
63 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
64 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
65 Field f(field);
66 This->haloExchange(f);
67 }
68
69 const parallel::HaloExchange* atlas__NodesFunctionSpace__get_halo_exchange(const NodeColumns* This) {
70 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
71 return &This->halo_exchange();
72 }
73
74 void atlas__NodesFunctionSpace__gather_fieldset(const NodeColumns* This, const field::FieldSetImpl* local,
75 field::FieldSetImpl* global) {
76 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
77 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised local atlas_FieldSet");
78 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised global atlas_FieldSet");
79 const FieldSet l(local);
80 FieldSet g(global);
81 This->gather(l, g);
82 }
83
84 void atlas__NodesFunctionSpace__gather_field(const NodeColumns* This, const field::FieldImpl* local,
85 field::FieldImpl* global) {
86 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
87 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised local atlas_Field");
88 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised global atlas_Field");
89 const Field l(local);
90 Field g(global);
91 This->gather(l, g);
92 }
93
94 const parallel::GatherScatter* atlas__NodesFunctionSpace__get_gather(const NodeColumns* This) {
95 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
96 return &This->gather();
97 }
98
99 const parallel::GatherScatter* atlas__NodesFunctionSpace__get_scatter(const NodeColumns* This) {
100 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
101 return &This->scatter();
102 }
103
104 void atlas__NodesFunctionSpace__scatter_fieldset(const NodeColumns* This, const field::FieldSetImpl* global,
105 field::FieldSetImpl* local) {
106 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
107 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised local atlas_FieldSet");
108 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised global atlas_FieldSet");
109 const FieldSet g(global);
110 FieldSet l(local);
111 This->scatter(g, l);
112 }
113
114 void atlas__NodesFunctionSpace__scatter_field(const NodeColumns* This, const field::FieldImpl* global,
115 field::FieldImpl* local) {
116 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
117 ATLAS_ASSERT(local != nullptr, "Cannot access uninitialised local atlas_Field");
118 ATLAS_ASSERT(global != nullptr, "Cannot access uninitialised global atlas_Field");
119 const Field g(global);
120 Field l(local);
121 This->scatter(g, l);
122 }
123
124 const parallel::Checksum* atlas__NodesFunctionSpace__get_checksum(const NodeColumns* This) {
125 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
126 return &This->checksum();
127 }
128
129 void atlas__NodesFunctionSpace__checksum_fieldset(const NodeColumns* This, const field::FieldSetImpl* fieldset,
130 char*& checksum, int& size, int& allocated) {
131 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
132 ATLAS_ASSERT(fieldset != nullptr, "Cannot access uninitialised atlas_FieldSet");
133 std::string checksum_str(This->checksum(fieldset));
134 size = static_cast<int>(checksum_str.size());
135 checksum = new char[size + 1];
136 allocated = true;
137 std::strncpy(checksum, checksum_str.c_str(), size + 1);
138 }
139
140 void atlas__NodesFunctionSpace__checksum_field(const NodeColumns* This, const field::FieldImpl* field, char*& checksum,
141 int& size, int& allocated) {
142 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
143 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
144 std::string checksum_str(This->checksum(field));
145 size = static_cast<int>(checksum_str.size());
146 checksum = new char[size + 1];
147 allocated = true;
148 std::strncpy(checksum, checksum_str.c_str(), size + 1);
149 }
150
151 void atlas__NodesFunctionSpace__sum_double(const NodeColumns* This, const field::FieldImpl* field, double& sum,
152 int& N) {
153 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
154 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
155 idx_t idx_t_N;
156 This->sum(field, sum, idx_t_N);
157 N = idx_t_N;
158 }
159
160 void atlas__NodesFunctionSpace__sum_float(const NodeColumns* This, const field::FieldImpl* field, float& sum, int& N) {
161 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
162 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
163 idx_t idx_t_N;
164 This->sum(field, sum, idx_t_N);
165 N = idx_t_N;
166 }
167
168 void atlas__NodesFunctionSpace__sum_long(const NodeColumns* This, const field::FieldImpl* field, long& sum, int& N) {
169 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
170 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
171 idx_t idx_t_N;
172 This->sum(field, sum, idx_t_N);
173 N = idx_t_N;
174 }
175
176 void atlas__NodesFunctionSpace__sum_int(const NodeColumns* This, const field::FieldImpl* field, int& sum, int& N) {
177 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
178 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
179 idx_t idx_t_N;
180 This->sum(field, sum, idx_t_N);
181 N = idx_t_N;
182 }
183
184 void atlas__NodesFunctionSpace__sum_arr_double(const NodeColumns* This, const field::FieldImpl* field, double*& sum,
185 int& size, int& N) {
186 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
187 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
188 idx_t idx_t_N;
189 std::vector<double> sumvec;
190 This->orderIndependentSum(field, sumvec, idx_t_N);
191 size = sumvec.size();
192 sum = new double[size];
193 for (idx_t j = 0; j < (idx_t)size; ++j) {
194 sum[j] = sumvec[j];
195 }
196 N = idx_t_N;
197 }
198
199 void atlas__NodesFunctionSpace__sum_arr_float(const NodeColumns* This, const field::FieldImpl* field, float*& sum,
200 int& size, int& N) {
201 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
202 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
203 idx_t idx_t_N;
204 std::vector<float> sumvec;
205 This->orderIndependentSum(field, sumvec, idx_t_N);
206 size = sumvec.size();
207 sum = new float[size];
208 for (idx_t j = 0; j < (idx_t)size; ++j) {
209 sum[j] = sumvec[j];
210 }
211 N = idx_t_N;
212 }
213
214 void atlas__NodesFunctionSpace__sum_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& sum,
215 int& size, int& N) {
216 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
217 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
218 idx_t idx_t_N;
219 std::vector<long> sumvec;
220 This->orderIndependentSum(field, sumvec, idx_t_N);
221 size = sumvec.size();
222 sum = new long[size];
223 for (idx_t j = 0; j < (idx_t)size; ++j) {
224 sum[j] = sumvec[j];
225 }
226 N = idx_t_N;
227 }
228
229 void atlas__NodesFunctionSpace__sum_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& sum,
230 int& size, int& N) {
231 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
232 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
233 idx_t idx_t_N;
234 std::vector<int> sumvec;
235 This->orderIndependentSum(field, sumvec, idx_t_N);
236 size = sumvec.size();
237 sum = new int[size];
238 for (idx_t j = 0; j < (idx_t)size; ++j) {
239 sum[j] = sumvec[j];
240 }
241 N = idx_t_N;
242 }
243
244 void atlas__NodesFunctionSpace__oisum_double(const NodeColumns* This, const field::FieldImpl* field, double& sum,
245 int& N) {
246 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
247 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
248 idx_t idx_t_N;
249 This->orderIndependentSum(field, sum, idx_t_N);
250 N = idx_t_N;
251 }
252
253 void atlas__NodesFunctionSpace__oisum_float(const NodeColumns* This, const field::FieldImpl* field, float& sum,
254 int& N) {
255 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
256 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
257 idx_t idx_t_N;
258 This->orderIndependentSum(field, sum, idx_t_N);
259 N = idx_t_N;
260 }
261
262 void atlas__NodesFunctionSpace__oisum_long(const NodeColumns* This, const field::FieldImpl* field, long& sum, int& N) {
263 atlas__NodesFunctionSpace__sum_long(This, field, sum, N);
264 }
265
266 void atlas__NodesFunctionSpace__oisum_int(const NodeColumns* This, const field::FieldImpl* field, int& sum, int& N) {
267 atlas__NodesFunctionSpace__sum_int(This, field, sum, N);
268 }
269
270 void atlas__NodesFunctionSpace__oisum_arr_double(const NodeColumns* This, const field::FieldImpl* field, double*& sum,
271 int& size, int& N) {
272 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
273 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
274 idx_t idx_t_N;
275 std::vector<double> sumvec;
276 This->orderIndependentSum(field, sumvec, idx_t_N);
277 size = sumvec.size();
278 sum = new double[size];
279 for (idx_t j = 0; j < (idx_t)size; ++j) {
280 sum[j] = sumvec[j];
281 }
282 N = idx_t_N;
283 }
284
285 void atlas__NodesFunctionSpace__oisum_arr_float(const NodeColumns* This, const field::FieldImpl* field, float*& sum,
286 int& size, int& N) {
287 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
288 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
289 idx_t idx_t_N;
290 std::vector<float> sumvec;
291 This->orderIndependentSum(field, sumvec, idx_t_N);
292 size = sumvec.size();
293 sum = new float[size];
294 for (idx_t j = 0; j < (idx_t)size; ++j) {
295 sum[j] = sumvec[j];
296 }
297 N = idx_t_N;
298 }
299
300 void atlas__NodesFunctionSpace__oisum_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& sum,
301 int& size, int& N) {
302 atlas__NodesFunctionSpace__sum_arr_int(This, field, sum, size, N);
303 }
304
305 void atlas__NodesFunctionSpace__oisum_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& sum,
306 int& size, int& N) {
307 atlas__NodesFunctionSpace__sum_arr_long(This, field, sum, size, N);
308 }
309
310
311 void atlas__NodesFunctionSpace__min_double(const NodeColumns* This, const field::FieldImpl* field, double& minimum) {
312 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
313 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
314 This->minimum(field, minimum);
315 }
316
317 void atlas__NodesFunctionSpace__min_float(const NodeColumns* This, const field::FieldImpl* field, float& minimum) {
318 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
319 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
320 This->minimum(field, minimum);
321 }
322
323 void atlas__NodesFunctionSpace__min_long(const NodeColumns* This, const field::FieldImpl* field, long& minimum) {
324 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
325 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
326 This->minimum(field, minimum);
327 }
328
329 void atlas__NodesFunctionSpace__min_int(const NodeColumns* This, const field::FieldImpl* field, int& minimum) {
330 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
331 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
332 This->minimum(field, minimum);
333 }
334
335 void atlas__NodesFunctionSpace__max_double(const NodeColumns* This, const field::FieldImpl* field, double& maximum) {
336 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
337 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
338 This->maximum(field, maximum);
339 }
340
341 void atlas__NodesFunctionSpace__max_float(const NodeColumns* This, const field::FieldImpl* field, float& maximum) {
342 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
343 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
344 This->maximum(field, maximum);
345 }
346
347 void atlas__NodesFunctionSpace__max_long(const NodeColumns* This, const field::FieldImpl* field, long& maximum) {
348 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
349 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
350 This->maximum(field, maximum);
351 }
352
353 void atlas__NodesFunctionSpace__max_int(const NodeColumns* This, const field::FieldImpl* field, int& maximum) {
354 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
355 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
356 This->maximum(field, maximum);
357 }
358
359 void atlas__NodesFunctionSpace__min_arr_double(const NodeColumns* This, const field::FieldImpl* field, double*& minimum,
360 int& size) {
361 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
362 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
363 std::vector<double> minvec;
364 This->minimum(field, minvec);
365 size = minvec.size();
366 minimum = new double[size];
367 for (idx_t j = 0; j < (idx_t)size; ++j) {
368 minimum[j] = minvec[j];
369 }
370 }
371
372 void atlas__NodesFunctionSpace__min_arr_float(const NodeColumns* This, const field::FieldImpl* field, float*& minimum,
373 int& size) {
374 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
375 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
376 std::vector<float> minvec;
377 This->minimum(field, minvec);
378 size = minvec.size();
379 minimum = new float[size];
380 for (idx_t j = 0; j < (idx_t)size; ++j) {
381 minimum[j] = minvec[j];
382 }
383 }
384
385 void atlas__NodesFunctionSpace__min_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& minimum,
386 int& size) {
387 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
388 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
389 std::vector<long> minvec;
390 This->minimum(field, minvec);
391 size = minvec.size();
392 minimum = new long[size];
393 for (idx_t j = 0; j < (idx_t)size; ++j) {
394 minimum[j] = minvec[j];
395 };
396 }
397
398 void atlas__NodesFunctionSpace__min_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& minimum,
399 int& size) {
400 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
401 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
402 std::vector<int> minvec;
403 This->minimum(field, minvec);
404 size = minvec.size();
405 minimum = new int[size];
406 for (idx_t j = 0; j < (idx_t)size; ++j) {
407 minimum[j] = minvec[j];
408 }
409 }
410
411 void atlas__NodesFunctionSpace__max_arr_double(const NodeColumns* This, const field::FieldImpl* field, double*& maximum,
412 int& size) {
413 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
414 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
415 std::vector<double> maxvec;
416 This->maximum(field, maxvec);
417 size = maxvec.size();
418 maximum = new double[size];
419 for (idx_t j = 0; j < (idx_t)size; ++j) {
420 maximum[j] = maxvec[j];
421 }
422 }
423
424 void atlas__NodesFunctionSpace__max_arr_float(const NodeColumns* This, const field::FieldImpl* field, float*& maximum,
425 int& size) {
426 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
427 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
428 std::vector<float> maxvec;
429 This->maximum(field, maxvec);
430 size = maxvec.size();
431 maximum = new float[size];
432 for (idx_t j = 0; j < (idx_t)size; ++j) {
433 maximum[j] = maxvec[j];
434 }
435 }
436
437 void atlas__NodesFunctionSpace__max_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& maximum,
438 int& size) {
439 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
440 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
441 std::vector<long> maxvec;
442 This->maximum(field, maxvec);
443 size = maxvec.size();
444 maximum = new long[size];
445 for (idx_t j = 0; j < (idx_t)size; ++j) {
446 maximum[j] = maxvec[j];
447 }
448 }
449
450 void atlas__NodesFunctionSpace__max_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& maximum,
451 int& size) {
452 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
453 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
454 std::vector<int> maxvec;
455 This->maximum(field, maxvec);
456 size = maxvec.size();
457 maximum = new int[size];
458 for (idx_t j = 0; j < (idx_t)size; ++j) {
459 maximum[j] = maxvec[j];
460 }
461 }
462
463 void atlas__NodesFunctionSpace__minloc_double(const NodeColumns* This, const field::FieldImpl* field, double& minimum,
464 long& glb_idx) {
465 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
466 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
467 gidx_t gidx;
468 This->minimumAndLocation(field, minimum, gidx);
469 glb_idx = gidx;
470 }
471
472 void atlas__NodesFunctionSpace__minloc_float(const NodeColumns* This, const field::FieldImpl* field, float& minimum,
473 long& glb_idx) {
474 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
475 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
476 gidx_t gidx;
477 This->minimumAndLocation(field, minimum, gidx);
478 glb_idx = gidx;
479 }
480
481 void atlas__NodesFunctionSpace__minloc_long(const NodeColumns* This, const field::FieldImpl* field, long& minimum,
482 long& glb_idx) {
483 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
484 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
485 gidx_t gidx;
486 This->minimumAndLocation(field, minimum, gidx);
487 glb_idx = gidx;
488 }
489
490 void atlas__NodesFunctionSpace__minloc_int(const NodeColumns* This, const field::FieldImpl* field, int& minimum,
491 long& glb_idx) {
492 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
493 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
494 gidx_t gidx;
495 This->minimumAndLocation(field, minimum, gidx);
496 glb_idx = gidx;
497 }
498
499 void atlas__NodesFunctionSpace__maxloc_double(const NodeColumns* This, const field::FieldImpl* field, double& maximum,
500 long& glb_idx) {
501 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
502 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
503 gidx_t gidx;
504 This->maximumAndLocation(field, maximum, gidx);
505 glb_idx = gidx;
506 }
507
508 void atlas__NodesFunctionSpace__maxloc_float(const NodeColumns* This, const field::FieldImpl* field, float& maximum,
509 long& glb_idx) {
510 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
511 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
512 gidx_t gidx;
513 This->maximumAndLocation(field, maximum, gidx);
514 glb_idx = gidx;
515 }
516
517 void atlas__NodesFunctionSpace__maxloc_long(const NodeColumns* This, const field::FieldImpl* field, long& maximum,
518 long& glb_idx) {
519 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
520 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
521 gidx_t gidx;
522 This->maximumAndLocation(field, maximum, gidx);
523 glb_idx = gidx;
524 }
525
526 void atlas__NodesFunctionSpace__maxloc_int(const NodeColumns* This, const field::FieldImpl* field, int& maximum,
527 long& glb_idx) {
528 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
529 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
530 gidx_t gidx;
531 This->maximumAndLocation(field, maximum, gidx);
532 glb_idx = gidx;
533 }
534
535 void atlas__NodesFunctionSpace__minloc_arr_double(const NodeColumns* This, const field::FieldImpl* field,
536 double*& minimum, long*& glb_idx, int& size) {
537 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
538 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
539 std::vector<double> minvec;
540 std::vector<gidx_t> gidxvec;
541 This->minimumAndLocation(field, minvec, gidxvec);
542 size = minvec.size();
543 minimum = new double[size];
544 glb_idx = new long[size];
545 for (idx_t j = 0; j < (idx_t)size; ++j) {
546 minimum[j] = minvec[j];
547 glb_idx[j] = gidxvec[j];
548 }
549 }
550
551 void atlas__NodesFunctionSpace__minloc_arr_float(const NodeColumns* This, const field::FieldImpl* field,
552 float*& minimum, long*& glb_idx, int& size) {
553 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
554 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
555 std::vector<float> minvec;
556 std::vector<gidx_t> gidxvec;
557 This->minimumAndLocation(field, minvec, gidxvec);
558 size = minvec.size();
559 minimum = new float[size];
560 glb_idx = new long[size];
561 for (idx_t j = 0; j < (idx_t)size; ++j) {
562 minimum[j] = minvec[j];
563 glb_idx[j] = gidxvec[j];
564 }
565 }
566
567 void atlas__NodesFunctionSpace__minloc_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& minimum,
568 long*& glb_idx, int& size) {
569 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
570 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
571 std::vector<long> minvec;
572 std::vector<gidx_t> gidxvec;
573 This->minimumAndLocation(field, minvec, gidxvec);
574 size = minvec.size();
575 minimum = new long[size];
576 glb_idx = new long[size];
577 for (idx_t j = 0; j < (idx_t)size; ++j) {
578 minimum[j] = minvec[j];
579 glb_idx[j] = gidxvec[j];
580 }
581 }
582
583 void atlas__NodesFunctionSpace__minloc_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& minimum,
584 long*& glb_idx, int& size) {
585 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
586 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
587 std::vector<int> minvec;
588 std::vector<gidx_t> gidxvec;
589 This->minimumAndLocation(field, minvec, gidxvec);
590 size = minvec.size();
591 minimum = new int[size];
592 glb_idx = new long[size];
593 for (idx_t j = 0; j < (idx_t)size; ++j) {
594 minimum[j] = minvec[j];
595 glb_idx[j] = gidxvec[j];
596 }
597 }
598
599 void atlas__NodesFunctionSpace__maxloc_arr_double(const NodeColumns* This, const field::FieldImpl* field,
600 double*& maximum, long*& glb_idx, int& size) {
601 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
602 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
603 std::vector<double> maxvec;
604 std::vector<gidx_t> gidxvec;
605 This->maximumAndLocation(field, maxvec, gidxvec);
606 size = maxvec.size();
607 maximum = new double[size];
608 glb_idx = new long[size];
609 for (idx_t j = 0; j < (idx_t)size; ++j) {
610 maximum[j] = maxvec[j];
611 glb_idx[j] = gidxvec[j];
612 }
613 }
614
615 void atlas__NodesFunctionSpace__maxloc_arr_float(const NodeColumns* This, const field::FieldImpl* field,
616 float*& maximum, long*& glb_idx, int& size) {
617 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
618 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
619 std::vector<float> maxvec;
620 std::vector<gidx_t> gidxvec;
621 This->maximumAndLocation(field, maxvec, gidxvec);
622 size = maxvec.size();
623 maximum = new float[size];
624 glb_idx = new long[size];
625 for (idx_t j = 0; j < (idx_t)size; ++j) {
626 maximum[j] = maxvec[j];
627 glb_idx[j] = gidxvec[j];
628 }
629 }
630
631 void atlas__NodesFunctionSpace__maxloc_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& maximum,
632 long*& glb_idx, int& size) {
633 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
634 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
635 std::vector<long> maxvec;
636 std::vector<gidx_t> gidxvec;
637 This->maximumAndLocation(field, maxvec, gidxvec);
638 size = maxvec.size();
639 maximum = new long[size];
640 glb_idx = new long[size];
641 for (idx_t j = 0; j < (idx_t)size; ++j) {
642 maximum[j] = maxvec[j];
643 glb_idx[j] = gidxvec[j];
644 }
645 }
646
647 void atlas__NodesFunctionSpace__maxloc_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& maximum,
648 long*& glb_idx, int& size) {
649 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
650 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
651 std::vector<int> maxvec;
652 std::vector<gidx_t> gidxvec;
653 This->maximumAndLocation(field, maxvec, gidxvec);
654 size = maxvec.size();
655 maximum = new int[size];
656 glb_idx = new long[size];
657 for (idx_t j = 0; j < (idx_t)size; ++j) {
658 maximum[j] = maxvec[j];
659 glb_idx[j] = gidxvec[j];
660 }
661 }
662
663 void atlas__NodesFunctionSpace__mean_double(const NodeColumns* This, const field::FieldImpl* field, double& mean,
664 int& N) {
665 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
666 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
667 idx_t idx_t_N;
668 This->mean(field, mean, idx_t_N);
669 N = idx_t_N;
670 }
671
672 void atlas__NodesFunctionSpace__mean_float(const NodeColumns* This, const field::FieldImpl* field, float& mean,
673 int& N) {
674 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
675 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
676 idx_t idx_t_N;
677 This->mean(field, mean, idx_t_N);
678 N = idx_t_N;
679 }
680
681 void atlas__NodesFunctionSpace__mean_long(const NodeColumns* This, const field::FieldImpl* field, long& mean, int& N) {
682 ATLAS_NOTIMPLEMENTED;
683 }
684
685 void atlas__NodesFunctionSpace__mean_int(const NodeColumns* This, const field::FieldImpl* field, int& mean, int& N) {
686 ATLAS_NOTIMPLEMENTED;
687 }
688
689 void atlas__NodesFunctionSpace__mean_arr_double(const NodeColumns* This, const field::FieldImpl* field, double*& mean,
690 int& size, int& N) {
691 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
692 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
693 idx_t idx_t_N;
694 std::vector<double> meanvec;
695 This->mean(field, meanvec, idx_t_N);
696 size = meanvec.size();
697 mean = new double[size];
698 for (idx_t j = 0; j < (idx_t)size; ++j) {
699 mean[j] = meanvec[j];
700 }
701 N = idx_t_N;
702 }
703
704 void atlas__NodesFunctionSpace__mean_arr_float(const NodeColumns* This, const field::FieldImpl* field, float*& mean,
705 int& size, int& N) {
706 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
707 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
708 idx_t idx_t_N;
709 std::vector<float> meanvec;
710 This->mean(field, meanvec, idx_t_N);
711 size = meanvec.size();
712 mean = new float[size];
713 for (idx_t j = 0; j < (idx_t)size; ++j) {
714 mean[j] = meanvec[j];
715 }
716 N = idx_t_N;
717 }
718
719 void atlas__NodesFunctionSpace__mean_arr_long(const NodeColumns* This, const field::FieldImpl* field, long*& mean,
720 int& size, int& N) {
721 ATLAS_NOTIMPLEMENTED;
722 }
723
724 void atlas__NodesFunctionSpace__mean_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& mean,
725 int& size, int& N) {
726 ATLAS_NOTIMPLEMENTED;
727 }
728
729 void atlas__NodesFunctionSpace__mean_and_stddev_double(const NodeColumns* This, const field::FieldImpl* field,
730 double& mean, double& stddev, int& N) {
731 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
732 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
733 idx_t idx_t_N;
734 This->meanAndStandardDeviation(field, mean, stddev, idx_t_N);
735 N = idx_t_N;
736 }
737
738 void atlas__NodesFunctionSpace__mean_and_stddev_float(const NodeColumns* This, const field::FieldImpl* field,
739 float& mean, float& stddev, int& N) {
740 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
741 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
742 idx_t idx_t_N;
743 This->meanAndStandardDeviation(field, mean, stddev, idx_t_N);
744 N = idx_t_N;
745 }
746
747 void atlas__NodesFunctionSpace__mean_and_stddev_long(const NodeColumns* This, const field::FieldImpl* field, long& mean,
748 long& stddev, int& N) {
749 ATLAS_NOTIMPLEMENTED;
750 }
751
752 void atlas__NodesFunctionSpace__mean_and_stddev_int(const NodeColumns* This, const field::FieldImpl* field, int& mean,
753 int& stddev, int& N) {
754 ATLAS_NOTIMPLEMENTED;
755 }
756
757 void atlas__NodesFunctionSpace__mean_and_stddev_arr_double(const NodeColumns* This, const field::FieldImpl* field,
758 double*& mean, double*& stddev, int& size, int& N) {
759 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
760 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
761 idx_t idx_t_N;
762 std::vector<double> meanvec;
763 std::vector<double> stddevvec;
764 This->meanAndStandardDeviation(field, meanvec, stddevvec, idx_t_N);
765 size = meanvec.size();
766 mean = new double[size];
767 stddev = new double[size];
768 for (idx_t j = 0; j < (idx_t)size; ++j) {
769 mean[j] = meanvec[j];
770 stddev[j] = stddevvec[j];
771 }
772 N = idx_t_N;
773 }
774
775 void atlas__NodesFunctionSpace__mean_and_stddev_arr_float(const NodeColumns* This, const field::FieldImpl* field,
776 float*& mean, float*& stddev, int& size, int& N) {
777 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
778 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
779 idx_t idx_t_N;
780 std::vector<float> meanvec;
781 std::vector<float> stddevvec;
782 This->meanAndStandardDeviation(field, meanvec, stddevvec, idx_t_N);
783 size = meanvec.size();
784 mean = new float[size];
785 stddev = new float[size];
786 for (idx_t j = 0; j < (idx_t)size; ++j) {
787 mean[j] = meanvec[j];
788 stddev[j] = stddevvec[j];
789 }
790 N = idx_t_N;
791 }
792
793 void atlas__NodesFunctionSpace__mean_and_stddev_arr_long(const NodeColumns* This, const field::FieldImpl* field,
794 long*& mean, long*& stddev, int& size, int& N) {
795 ATLAS_NOTIMPLEMENTED;
796 }
797
798 void atlas__NodesFunctionSpace__mean_and_stddev_arr_int(const NodeColumns* This, const field::FieldImpl* field,
799 int*& mean, int*& stddev, int& size, int& N) {
800 ATLAS_NOTIMPLEMENTED;
801 }
802
803 void atlas__NodesFunctionSpace__minloclev_double(const NodeColumns* This, const field::FieldImpl* field,
804 double& minimum, long& glb_idx, int& level) {
805 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
806 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
807 gidx_t gidx;
808 idx_t lev;
809 This->minimumAndLocation(field, minimum, gidx, lev);
810 glb_idx = gidx;
811 level = lev;
812 }
813
814 void atlas__NodesFunctionSpace__minloclev_float(const NodeColumns* This, const field::FieldImpl* field, float& minimum,
815 long& glb_idx, int& level) {
816 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
817 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
818 gidx_t gidx;
819 idx_t lev;
820 This->minimumAndLocation(field, minimum, gidx, lev);
821 glb_idx = gidx;
822 level = lev;
823 }
824
825 void atlas__NodesFunctionSpace__minloclev_long(const NodeColumns* This, const field::FieldImpl* field, long& minimum,
826 long& glb_idx, int& level) {
827 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
828 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
829 gidx_t gidx;
830 idx_t lev;
831 This->minimumAndLocation(field, minimum, gidx, lev);
832 glb_idx = gidx;
833 level = lev;
834 }
835
836 void atlas__NodesFunctionSpace__minloclev_int(const NodeColumns* This, const field::FieldImpl* field, int& minimum,
837 long& glb_idx, int& level) {
838 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
839 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
840 gidx_t gidx;
841 idx_t lev;
842 This->minimumAndLocation(field, minimum, gidx, lev);
843 glb_idx = gidx;
844 level = lev;
845 }
846
847 void atlas__NodesFunctionSpace__maxloclev_double(const NodeColumns* This, const field::FieldImpl* field,
848 double& maximum, long& glb_idx, int& level) {
849 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
850 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
851 gidx_t gidx;
852 idx_t lev;
853 This->maximumAndLocation(field, maximum, gidx, lev);
854 glb_idx = gidx;
855 level = lev;
856 }
857
858 void atlas__NodesFunctionSpace__maxloclev_float(const NodeColumns* This, const field::FieldImpl* field, float& maximum,
859 long& glb_idx, int& level) {
860 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
861 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
862 gidx_t gidx;
863 idx_t lev;
864 This->maximumAndLocation(field, maximum, gidx, lev);
865 glb_idx = gidx;
866 level = lev;
867 }
868
869 void atlas__NodesFunctionSpace__maxloclev_long(const NodeColumns* This, const field::FieldImpl* field, long& maximum,
870 long& glb_idx, int& level) {
871 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
872 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
873 gidx_t gidx;
874 idx_t lev;
875 This->maximumAndLocation(field, maximum, gidx, lev);
876 glb_idx = gidx;
877 level = lev;
878 }
879
880 void atlas__NodesFunctionSpace__maxloclev_int(const NodeColumns* This, const field::FieldImpl* field, int& maximum,
881 long& glb_idx, int& level) {
882 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
883 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
884 gidx_t gidx;
885 idx_t lev;
886 This->maximumAndLocation(field, maximum, gidx, lev);
887 glb_idx = gidx;
888 level = lev;
889 }
890
891 void atlas__NodesFunctionSpace__minloclev_arr_double(const NodeColumns* This, const field::FieldImpl* field,
892 double*& minimum, long*& glb_idx, int*& level, int& size) {
893 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
894 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
895 std::vector<double> minvec;
896 std::vector<gidx_t> gidxvec;
897 std::vector<idx_t> levvec;
898 This->minimumAndLocation(field, minvec, gidxvec, levvec);
899 size = minvec.size();
900 minimum = new double[size];
901 glb_idx = new long[size];
902 level = new int[size];
903 for (idx_t j = 0; j < (idx_t)size; ++j) {
904 minimum[j] = minvec[j];
905 glb_idx[j] = gidxvec[j];
906 level[j] = levvec[j];
907 }
908 }
909
910 void atlas__NodesFunctionSpace__minloclev_arr_float(const NodeColumns* This, const field::FieldImpl* field,
911 float*& minimum, long*& glb_idx, int*& level, int& size) {
912 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
913 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
914 std::vector<float> minvec;
915 std::vector<gidx_t> gidxvec;
916 std::vector<idx_t> levvec;
917 This->minimumAndLocation(field, minvec, gidxvec, levvec);
918 size = minvec.size();
919 minimum = new float[size];
920 glb_idx = new long[size];
921 level = new int[size];
922 for (idx_t j = 0; j < (idx_t)size; ++j) {
923 minimum[j] = minvec[j];
924 glb_idx[j] = gidxvec[j];
925 level[j] = levvec[j];
926 };
927 }
928
929 void atlas__NodesFunctionSpace__minloclev_arr_long(const NodeColumns* This, const field::FieldImpl* field,
930 long*& minimum, long*& glb_idx, int*& level, int& size) {
931 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
932 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
933 std::vector<long> minvec;
934 std::vector<gidx_t> gidxvec;
935 std::vector<idx_t> levvec;
936 This->minimumAndLocation(field, minvec, gidxvec, levvec);
937 size = minvec.size();
938 minimum = new long[size];
939 glb_idx = new long[size];
940 level = new int[size];
941 for (idx_t j = 0; j < (idx_t)size; ++j) {
942 minimum[j] = minvec[j];
943 glb_idx[j] = gidxvec[j];
944 level[j] = levvec[j];
945 }
946 }
947
948 void atlas__NodesFunctionSpace__minloclev_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& minimum,
949 long*& glb_idx, int*& level, int& size) {
950 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
951 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
952 std::vector<int> minvec;
953 std::vector<gidx_t> gidxvec;
954 std::vector<idx_t> levvec;
955 This->minimumAndLocation(field, minvec, gidxvec, levvec);
956 size = minvec.size();
957 minimum = new int[size];
958 glb_idx = new long[size];
959 level = new int[size];
960 for (idx_t j = 0; j < (idx_t)size; ++j) {
961 minimum[j] = minvec[j];
962 glb_idx[j] = gidxvec[j];
963 level[j] = levvec[j];
964 };
965 }
966
967 void atlas__NodesFunctionSpace__maxloclev_arr_double(const NodeColumns* This, const field::FieldImpl* field,
968 double*& maximum, long*& glb_idx, int*& level, int& size) {
969 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
970 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
971 std::vector<double> maxvec;
972 std::vector<gidx_t> gidxvec;
973 std::vector<idx_t> levvec;
974 This->maximumAndLocation(field, maxvec, gidxvec, levvec);
975 size = maxvec.size();
976 maximum = new double[size];
977 glb_idx = new long[size];
978 level = new int[size];
979 for (idx_t j = 0; j < (idx_t)size; ++j) {
980 maximum[j] = maxvec[j];
981 glb_idx[j] = gidxvec[j];
982 level[j] = levvec[j];
983 }
984 }
985
986 void atlas__NodesFunctionSpace__maxloclev_arr_float(const NodeColumns* This, const field::FieldImpl* field,
987 float*& maximum, long*& glb_idx, int*& level, int& size) {
988 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
989 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
990 std::vector<float> maxvec;
991 std::vector<gidx_t> gidxvec;
992 std::vector<idx_t> levvec;
993 This->maximumAndLocation(field, maxvec, gidxvec, levvec);
994 size = maxvec.size();
995 maximum = new float[size];
996 glb_idx = new long[size];
997 level = new int[size];
998 for (idx_t j = 0; j < (idx_t)size; ++j) {
999 maximum[j] = maxvec[j];
1000 glb_idx[j] = gidxvec[j];
1001 level[j] = levvec[j];
1002 }
1003 }
1004
1005 void atlas__NodesFunctionSpace__maxloclev_arr_long(const NodeColumns* This, const field::FieldImpl* field,
1006 long*& maximum, long*& glb_idx, int*& level, int& size) {
1007 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1008 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1009 std::vector<long> maxvec;
1010 std::vector<gidx_t> gidxvec;
1011 std::vector<idx_t> levvec;
1012 This->maximumAndLocation(field, maxvec, gidxvec, levvec);
1013 size = maxvec.size();
1014 maximum = new long[size];
1015 glb_idx = new long[size];
1016 level = new int[size];
1017 for (idx_t j = 0; j < (idx_t)size; ++j) {
1018 maximum[j] = maxvec[j];
1019 glb_idx[j] = gidxvec[j];
1020 level[j] = levvec[j];
1021 }
1022 }
1023
1024 void atlas__NodesFunctionSpace__maxloclev_arr_int(const NodeColumns* This, const field::FieldImpl* field, int*& maximum,
1025 long*& glb_idx, int*& level, int& size) {
1026 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1027 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1028 std::vector<int> maxvec;
1029 std::vector<gidx_t> gidxvec;
1030 std::vector<idx_t> levvec;
1031 This->maximumAndLocation(field, maxvec, gidxvec, levvec);
1032 size = maxvec.size();
1033 maximum = new int[size];
1034 glb_idx = new long[size];
1035 level = new int[size];
1036 for (idx_t j = 0; j < (idx_t)size; ++j) {
1037 maximum[j] = maxvec[j];
1038 glb_idx[j] = gidxvec[j];
1039 level[j] = levvec[j];
1040 }
1041 }
1042
1043 void atlas__NodesFunctionSpace__sum_per_level(const NodeColumns* This, const field::FieldImpl* field,
1044 field::FieldImpl* column, int& N) {
1045 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1046 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1047 ATLAS_ASSERT(column != nullptr, "Cannot access uninitialised atlas_Field");
1048 idx_t idx_t_N;
1049 Field sum(column);
1050 This->sumPerLevel(field, sum, idx_t_N);
1051 N = idx_t_N;
1052 }
1053
1054 void atlas__NodesFunctionSpace__oisum_per_level(const NodeColumns* This, const field::FieldImpl* field,
1055 field::FieldImpl* column, int& N) {
1056 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1057 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1058 ATLAS_ASSERT(column != nullptr, "Cannot access uninitialised atlas_Field");
1059 idx_t idx_t_N;
1060 Field sum(column);
1061 This->orderIndependentSumPerLevel(field, sum, idx_t_N);
1062 N = idx_t_N;
1063 }
1064
1065 void atlas__NodesFunctionSpace__min_per_level(const NodeColumns* This, const field::FieldImpl* field,
1066 field::FieldImpl* min) {
1067 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1068 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1069 ATLAS_ASSERT(min != nullptr, "Cannot access uninitialised min atlas_Field");
1070 Field fmin(min);
1071 This->minimumPerLevel(field, fmin);
1072 }
1073
1074 void atlas__NodesFunctionSpace__max_per_level(const NodeColumns* This, const field::FieldImpl* field,
1075 field::FieldImpl* max) {
1076 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1077 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1078 ATLAS_ASSERT(max != nullptr, "Cannot access uninitialised max atlas_Field");
1079 Field fmax(max);
1080 This->maximumPerLevel(field, fmax);
1081 }
1082
1083 void atlas__NodesFunctionSpace__minloc_per_level(const NodeColumns* This, const field::FieldImpl* field,
1084 field::FieldImpl* min, field::FieldImpl* glb_idx) {
1085 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1086 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1087 ATLAS_ASSERT(min != nullptr, "Cannot access uninitialised min atlas_Field");
1088 ATLAS_ASSERT(glb_idx != nullptr, "Cannot access uninitialised glb_idx atlas_Field");
1089 Field fmin(min);
1090 Field fglb_idx(glb_idx);
1091 This->minimumAndLocationPerLevel(field, fmin, fglb_idx);
1092 }
1093
1094 void atlas__NodesFunctionSpace__maxloc_per_level(const NodeColumns* This, const field::FieldImpl* field,
1095 field::FieldImpl* max, field::FieldImpl* glb_idx) {
1096 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1097 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1098 ATLAS_ASSERT(max != nullptr, "Cannot access uninitialised max atlas_Field");
1099 ATLAS_ASSERT(glb_idx != nullptr, "Cannot access uninitialised glb_idx atlas_Field");
1100 Field fmax(max);
1101 Field fglb_idx(glb_idx);
1102 This->maximumAndLocationPerLevel(field, fmax, fglb_idx);
1103 }
1104
1105 void atlas__NodesFunctionSpace__mean_per_level(const NodeColumns* This, const field::FieldImpl* field,
1106 field::FieldImpl* mean, int& N) {
1107 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1108 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1109 ATLAS_ASSERT(mean != nullptr, "Cannot access uninitialised mean atlas_Field");
1110 idx_t idx_t_N;
1111 Field fmean(mean);
1112 This->meanPerLevel(field, fmean, idx_t_N);
1113 N = idx_t_N;
1114 }
1115
1116 void atlas__NodesFunctionSpace__mean_and_stddev_per_level(const NodeColumns* This, const field::FieldImpl* field,
1117 field::FieldImpl* mean, field::FieldImpl* stddev, int& N) {
1118 ATLAS_ASSERT(This != nullptr, "Cannot access uninitialised atlas_functionspace_NodeColumns");
1119 ATLAS_ASSERT(field != nullptr, "Cannot access uninitialised atlas_Field");
1120 ATLAS_ASSERT(mean != nullptr, "Cannot access uninitialised mean atlas_Field");
1121 ATLAS_ASSERT(stddev);
1122 idx_t idx_t_N;
1123 Field fmean(mean);
1124 Field fstddev(stddev);
1125 This->meanAndStandardDeviationPerLevel(field, fmean, fstddev, idx_t_N);
1126 N = idx_t_N;
1127 }
1128 }
1129
1130 } // namespace detail
1131 } // namespace functionspace
1132 } // namespace atlas