Debian Codegraph @

src/atlas/functionspace/EdgeColumns.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 <functional>
14
15 #include "eckit/utils/MD5.h"
16
17 #include "atlas/array/MakeView.h"
18 #include "atlas/field/detail/FieldImpl.h"
19 #include "atlas/functionspace/EdgeColumns.h"
20 #include "atlas/grid/UnstructuredGrid.h"
21 #include "atlas/library/config.h"
22 #include "atlas/mesh/HybridElements.h"
23 #include "atlas/mesh/IsGhostNode.h"
24 #include "atlas/mesh/Mesh.h"
25 #include "atlas/mesh/actions/BuildEdges.h"
26 #include "atlas/mesh/actions/BuildHalo.h"
27 #include "atlas/mesh/actions/BuildParallelFields.h"
28 #include "atlas/mesh/actions/BuildPeriodicBoundaries.h"
29 #include "atlas/parallel/Checksum.h"
30 #include "atlas/parallel/GatherScatter.h"
31 #include "atlas/parallel/HaloExchange.h"
32 #include "atlas/parallel/omp/omp.h"
33 #include "atlas/runtime/Exception.h"
34 #include "atlas/runtime/Log.h"
35 #include "atlas/runtime/Trace.h"
36 #include "atlas/util/detail/Cache.h"
37
38 #include "atlas/field/detail/FieldImpl.h"
39
40 #if ATLAS_HAVE_FORTRAN
41 #define REMOTE_IDX_BASE 1
42 #else
43 #define REMOTE_IDX_BASE 0
44 #endif
45
46 namespace atlas {
47 namespace functionspace {
48 namespace detail {
49
50 namespace {
51 template <typename T, typename Field>
52 array::LocalView<T, 3> make_leveled_view(Field& field) {
53 using namespace array;
54 if (field.levels()) {
55 if (field.variables()) {
56 return make_view<T, 3>(field).slice(Range::all(), Range::all(), Range::all());
57 }
58 else {
59 return make_view<T, 2>(field).slice(Range::all(), Range::all(), Range::dummy());
60 }
61 }
62 else {
63 if (field.variables()) {
64 return make_view<T, 2>(field).slice(Range::all(), Range::dummy(), Range::all());
65 }
66 else {
67 return make_view<T, 1>(field).slice(Range::all(), Range::dummy(), Range::dummy());
68 }
69 }
70 }
71 } // namespace
72
73 class EdgeColumnsHaloExchangeCache : public util::Cache<std::string, parallel::HaloExchange>,
74 public mesh::detail::MeshObserver {
75 private:
76 using Base = util::Cache<std::string, parallel::HaloExchange>;
77 EdgeColumnsHaloExchangeCache(): Base("EdgeColumnsHaloExchangeCache") {}
78
79 public:
80 static EdgeColumnsHaloExchangeCache& instance() {
81 static EdgeColumnsHaloExchangeCache inst;
82 return inst;
83 }
84 util::ObjectHandle<value_type> get_or_create(const Mesh& mesh) {
85 registerMesh(*mesh.get());
86 creator_type creator = std::bind(&EdgeColumnsHaloExchangeCache::create, mesh);
87 return Base::get_or_create(key(*mesh.get()), creator);
88 }
89 void onMeshDestruction(mesh::detail::MeshImpl& mesh) override { remove(key(mesh)); }
90
91 private:
92 static Base::key_type key(const mesh::detail::MeshImpl& mesh) {
93 std::ostringstream key;
94 key << "mesh[address=" << &mesh << "]";
95 return key.str();
96 }
97
98 static value_type* create(const Mesh& mesh) {
99 value_type* value = new value_type();
100 value->setup(mesh.mpi_comm(),
101 array::make_view<int, 1>(mesh.edges().partition()).data(),
102 array::make_view<idx_t, 1>(mesh.edges().remote_index()).data(), REMOTE_IDX_BASE,
103 mesh.edges().size());
104 return value;
105 }
106 };
107
108 class EdgeColumnsGatherScatterCache : public util::Cache<std::string, parallel::GatherScatter>,
109 public mesh::detail::MeshObserver {
110 private:
111 using Base = util::Cache<std::string, parallel::GatherScatter>;
112 EdgeColumnsGatherScatterCache(): Base("EdgeColumnsGatherScatterCache") {}
113
114 public:
115 static EdgeColumnsGatherScatterCache& instance() {
116 static EdgeColumnsGatherScatterCache inst;
117 return inst;
118 }
119 util::ObjectHandle<value_type> get_or_create(const Mesh& mesh) {
120 registerMesh(*mesh.get());
121 creator_type creator = std::bind(&EdgeColumnsGatherScatterCache::create, mesh);
122 return Base::get_or_create(key(*mesh.get()), creator);
123 }
124 void onMeshDestruction(mesh::detail::MeshImpl& mesh) override { remove(key(mesh)); }
125
126 private:
127 static Base::key_type key(const mesh::detail::MeshImpl& mesh) {
128 std::ostringstream key;
129 key << "mesh[address=" << &mesh << "]";
130 return key.str();
131 }
132
133 static value_type* create(const Mesh& mesh) {
134 value_type* value = new value_type();
135 value->setup(mesh.mpi_comm(),
136 array::make_view<int, 1>(mesh.edges().partition()).data(),
137 array::make_view<idx_t, 1>(mesh.edges().remote_index()).data(), REMOTE_IDX_BASE,
138 array::make_view<gidx_t, 1>(mesh.edges().global_index()).data(), mesh.edges().size());
139 return value;
140 }
141 };
142
143 class EdgeColumnsChecksumCache : public util::Cache<std::string, parallel::Checksum>,
144 public mesh::detail::MeshObserver {
145 private:
146 using Base = util::Cache<std::string, parallel::Checksum>;
147 EdgeColumnsChecksumCache(): Base("EdgeColumnsChecksumCache") {}
148
149 public:
150 static EdgeColumnsChecksumCache& instance() {
151 static EdgeColumnsChecksumCache inst;
152 return inst;
153 }
154 util::ObjectHandle<value_type> get_or_create(const Mesh& mesh) {
155 registerMesh(*mesh.get());
156 creator_type creator = std::bind(&EdgeColumnsChecksumCache::create, mesh);
157 return Base::get_or_create(key(*mesh.get()), creator);
158 }
159 void onMeshDestruction(mesh::detail::MeshImpl& mesh) override { remove(key(mesh)); }
160
161 private:
162 static Base::key_type key(const mesh::detail::MeshImpl& mesh) {
163 std::ostringstream key;
164 key << "mesh[address=" << &mesh << "]";
165 return key.str();
166 }
167
168 static value_type* create(const Mesh& mesh) {
169 value_type* value = new value_type();
170 util::ObjectHandle<parallel::GatherScatter> gather(
171 EdgeColumnsGatherScatterCache::instance().get_or_create(mesh));
172 value->setup(gather);
173 return value;
174 }
175 };
176
177 void EdgeColumns::set_field_metadata(const eckit::Configuration& config, Field& field) const {
178 field.set_functionspace(this);
179
180 bool global(false);
181 if (config.get("global", global)) {
182 if (global) {
183 idx_t owner(0);
184 config.get("owner", owner);
185 field.metadata().set("owner", owner);
186 }
187 }
188 field.metadata().set("global", global);
189
190 idx_t levels(nb_levels_);
191 config.get("levels", levels);
192 field.set_levels(levels);
193
194 idx_t variables(0);
195 config.get("variables", variables);
196 field.set_variables(variables);
197 }
198
199 idx_t EdgeColumns::config_size(const eckit::Configuration& config) const {
200 idx_t size = nb_edges();
201 bool global(false);
202 if (config.get("global", global)) {
203 if (global) {
204 idx_t owner(0);
205 config.get("owner", owner);
206 idx_t _nb_edges_global(nb_edges_global());
207 const idx_t rank = mpi::comm(mpi_comm()).rank();
208 size = (rank == owner ? _nb_edges_global : 0);
209 }
210 }
211 return size;
212 }
213
214 array::DataType EdgeColumns::config_datatype(const eckit::Configuration& config) const {
215 array::DataType::kind_t kind;
216 if (!config.get("datatype", kind)) {
217 throw_Exception("datatype missing", Here());
218 }
219 return array::DataType(kind);
220 }
221
222 std::string EdgeColumns::config_name(const eckit::Configuration& config) const {
223 std::string name;
224 config.get("name", name);
225 return name;
226 }
227
228 idx_t EdgeColumns::config_levels(const eckit::Configuration& config) const {
229 idx_t levels(nb_levels_);
230 config.get("levels", levels);
231 return levels;
232 }
233
234 array::ArrayShape EdgeColumns::config_shape(const eckit::Configuration& config) const {
235 array::ArrayShape shape;
236
237 shape.push_back(config_size(config));
238
239 idx_t levels(nb_levels_);
240 config.get("levels", levels);
241 if (levels > 0) {
242 shape.push_back(levels);
243 }
244
245 idx_t variables(0);
246 config.get("variables", variables);
247 if (variables > 0) {
248 shape.push_back(variables);
249 }
250
251 return shape;
252 }
253
254 EdgeColumns::EdgeColumns(const Mesh& mesh, const eckit::Configuration& config):
255 mesh_(mesh), edges_(mesh_.edges()), nb_levels_(config.getInt("levels", 0)), nb_edges_(0) {
256 ATLAS_TRACE();
257 if (config.has("halo")) {
258 halo_ = mesh::Halo(config.getInt("halo"));
259 }
260 else {
261 halo_ = mesh::Halo(mesh_);
262 }
263
264 auto get_nb_edges_from_metadata = [&]() {
265 idx_t _nb_edges(0);
266 std::stringstream ss;
267 ss << "nb_edges_including_halo[" << halo_.size() << "]";
268 mesh_.metadata().get(ss.str(), _nb_edges);
269 return _nb_edges;
270 };
271
272 mesh::actions::build_nodes_parallel_fields(mesh_);
273 mesh::actions::build_periodic_boundaries(mesh_);
274
275 if (halo_.size() > 0) {
276 mesh::actions::build_halo(mesh_, halo_.size());
277 nb_edges_ = get_nb_edges_from_metadata();
278 }
279 if (!nb_edges_) {
280 mesh::actions::build_edges(mesh_, config);
281 mesh::actions::build_edges_parallel_fields(mesh_);
282 nb_edges_ = get_nb_edges_from_metadata();
283 }
284 ATLAS_ASSERT(nb_edges_);
285
286 if (mesh_.grid()) {
287 grid_ = mesh_.grid();
288 }
289 }
290
291 EdgeColumns::~EdgeColumns() = default;
292
293 size_t EdgeColumns::footprint() const {
294 size_t size = sizeof(*this);
295 // TODO
296 return size;
297 }
298
299 std::string EdgeColumns::distribution() const {
300 return mesh().metadata().getString("distribution");
301 }
302
303 idx_t EdgeColumns::nb_edges() const {
304 return nb_edges_;
305 }
306
307 idx_t EdgeColumns::nb_edges_global() const {
308 if (nb_edges_global_ >= 0) {
309 return nb_edges_global_;
310 }
311 nb_edges_global_ = gather().glb_dof();
312 return nb_edges_global_;
313 }
314
315 Field EdgeColumns::createField(const eckit::Configuration& options) const {
316 Field field(config_name(options), config_datatype(options), config_shape(options));
317 set_field_metadata(options, field);
318 return field;
319 }
320
321 Field EdgeColumns::createField(const Field& other, const eckit::Configuration& config) const {
322 return createField(option::datatype(other.datatype()) | option::levels(other.levels()) |
323 option::variables(other.variables()) | config);
324 }
325
326 namespace {
327
328 template <int RANK>
329 void dispatch_haloExchange(Field& field, const parallel::HaloExchange& halo_exchange, bool on_device) {
330 if (field.datatype() == array::DataType::kind<int>()) {
331 halo_exchange.template execute<int, RANK>(field.array(), on_device);
332 }
333 else if (field.datatype() == array::DataType::kind<long>()) {
334 halo_exchange.template execute<long, RANK>(field.array(), on_device);
335 }
336 else if (field.datatype() == array::DataType::kind<float>()) {
337 halo_exchange.template execute<float, RANK>(field.array(), on_device);
338 }
339 else if (field.datatype() == array::DataType::kind<double>()) {
340 halo_exchange.template execute<double, RANK>(field.array(), on_device);
341 }
342 else {
343 throw_Exception("datatype not supported", Here());
344 }
345 field.set_dirty(false);
346 }
347 } // namespace
348
349 void EdgeColumns::haloExchange(const FieldSet& fieldset, bool on_device) const {
350 for (idx_t f = 0; f < fieldset.size(); ++f) {
351 Field& field = const_cast<FieldSet&>(fieldset)[f];
352 switch (field.rank()) {
353 case 1:
354 dispatch_haloExchange<1>(field, halo_exchange(), on_device);
355 break;
356 case 2:
357 dispatch_haloExchange<2>(field, halo_exchange(), on_device);
358 break;
359 case 3:
360 dispatch_haloExchange<3>(field, halo_exchange(), on_device);
361 break;
362 case 4:
363 dispatch_haloExchange<4>(field, halo_exchange(), on_device);
364 break;
365 default:
366 throw_Exception("Rank not supported", Here());
367 }
368 field.set_dirty(false);
369 }
370 }
371 void EdgeColumns::haloExchange(const Field& field, bool on_device) const {
372 FieldSet fieldset;
373 fieldset.add(field);
374 haloExchange(fieldset, on_device);
375 }
376
377 const parallel::HaloExchange& EdgeColumns::halo_exchange() const {
378 if (halo_exchange_) {
379 return *halo_exchange_;
380 }
381 halo_exchange_ = EdgeColumnsHaloExchangeCache::instance().get_or_create(mesh_);
382 return *halo_exchange_;
383 }
384
385 void EdgeColumns::gather(const FieldSet& local_fieldset, FieldSet& global_fieldset) const {
386 ATLAS_ASSERT(local_fieldset.size() == global_fieldset.size());
387
388 for (idx_t f = 0; f < local_fieldset.size(); ++f) {
389 const Field& loc = local_fieldset[f];
390 Field& glb = global_fieldset[f];
391 const idx_t nb_fields = 1;
392 idx_t root(0);
393 glb.metadata().get("owner", root);
394 if (loc.datatype() == array::DataType::kind<int>()) {
395 parallel::Field<int const> loc_field(make_leveled_view<const int>(loc));
396 parallel::Field<int> glb_field(make_leveled_view<int>(glb));
397 gather().gather(&loc_field, &glb_field, nb_fields, root);
398 }
399 else if (loc.datatype() == array::DataType::kind<long>()) {
400 parallel::Field<long const> loc_field(make_leveled_view<const long>(loc));
401 parallel::Field<long> glb_field(make_leveled_view<long>(glb));
402 gather().gather(&loc_field, &glb_field, nb_fields, root);
403 }
404 else if (loc.datatype() == array::DataType::kind<float>()) {
405 parallel::Field<float const> loc_field(make_leveled_view<const float>(loc));
406 parallel::Field<float> glb_field(make_leveled_view<float>(glb));
407 gather().gather(&loc_field, &glb_field, nb_fields, root);
408 }
409 else if (loc.datatype() == array::DataType::kind<double>()) {
410 parallel::Field<double const> loc_field(make_leveled_view<const double>(loc));
411 parallel::Field<double> glb_field(make_leveled_view<double>(glb));
412 gather().gather(&loc_field, &glb_field, nb_fields, root);
413 }
414 else {
415 throw_Exception("datatype not supported", Here());
416 }
417 }
418 }
419
420 void EdgeColumns::gather(const Field& local, Field& global) const {
421 FieldSet local_fields;
422 FieldSet global_fields;
423 local_fields.add(local);
424 global_fields.add(global);
425 gather(local_fields, global_fields);
426 }
427 const parallel::GatherScatter& EdgeColumns::gather() const {
428 if (gather_scatter_) {
429 return *gather_scatter_;
430 }
431 gather_scatter_ = EdgeColumnsGatherScatterCache::instance().get_or_create(mesh_);
432 return *gather_scatter_;
433 }
434 const parallel::GatherScatter& EdgeColumns::scatter() const {
435 if (gather_scatter_) {
436 return *gather_scatter_;
437 }
438 gather_scatter_ = EdgeColumnsGatherScatterCache::instance().get_or_create(mesh_);
439 return *gather_scatter_;
440 }
441
442 void EdgeColumns::scatter(const FieldSet& global_fieldset, FieldSet& local_fieldset) const {
443 ATLAS_ASSERT(local_fieldset.size() == global_fieldset.size());
444
445 for (idx_t f = 0; f < local_fieldset.size(); ++f) {
446 const Field& glb = global_fieldset[f];
447 Field& loc = local_fieldset[f];
448 const idx_t nb_fields = 1;
449 idx_t root(0);
450 glb.metadata().get("owner", root);
451
452 if (loc.datatype() == array::DataType::kind<int>()) {
453 parallel::Field<int const> glb_field(make_leveled_view<const int>(glb));
454 parallel::Field<int> loc_field(make_leveled_view<int>(loc));
455 scatter().scatter(&glb_field, &loc_field, nb_fields, root);
456 }
457 else if (loc.datatype() == array::DataType::kind<long>()) {
458 parallel::Field<long const> glb_field(make_leveled_view<const long>(glb));
459 parallel::Field<long> loc_field(make_leveled_view<long>(loc));
460 scatter().scatter(&glb_field, &loc_field, nb_fields, root);
461 }
462 else if (loc.datatype() == array::DataType::kind<float>()) {
463 parallel::Field<float const> glb_field(make_leveled_view<const float>(glb));
464 parallel::Field<float> loc_field(make_leveled_view<float>(loc));
465 scatter().scatter(&glb_field, &loc_field, nb_fields, root);
466 }
467 else if (loc.datatype() == array::DataType::kind<double>()) {
468 parallel::Field<double const> glb_field(make_leveled_view<const double>(glb));
469 parallel::Field<double> loc_field(make_leveled_view<double>(loc));
470 scatter().scatter(&glb_field, &loc_field, nb_fields, root);
471 }
472 else {
473 throw_Exception("datatype not supported", Here());
474 }
475
476 glb.metadata().broadcast(loc.metadata(), root);
477 loc.metadata().set("global", false);
478 loc.set_dirty(true);
479 }
480 }
481 void EdgeColumns::scatter(const Field& global, Field& local) const {
482 FieldSet global_fields;
483 FieldSet local_fields;
484 global_fields.add(global);
485 local_fields.add(local);
486 scatter(global_fields, local_fields);
487 }
488
489 namespace {
490 template <typename T>
491 std::string checksum_3d_field(const parallel::Checksum& checksum, const Field& field) {
492 auto values = array::make_view<T, 3>(field);
493 array::ArrayT<T> surface_field(field.shape(0), field.shape(2));
494 auto surface = array::make_view<T, 2>(surface_field);
495 for (idx_t n = 0; n < values.shape(0); ++n) {
496 for (idx_t j = 0; j < surface.shape(1); ++j) {
497 surface(n, j) = 0.;
498 for (idx_t l = 0; l < values.shape(1); ++l) {
499 surface(n, j) += values(n, l, j);
500 }
501 }
502 }
503 return checksum.execute(surface.data(), surface_field.stride(0));
504 }
505 template <typename T>
506 std::string checksum_2d_field(const parallel::Checksum& checksum, const Field& field) {
507 auto values = array::make_view<T, 2>(field);
508 return checksum.execute(values.data(), field.stride(0));
509 }
510
511 } // namespace
512
513 std::string EdgeColumns::checksum(const FieldSet& fieldset) const {
514 eckit::MD5 md5;
515 for (idx_t f = 0; f < fieldset.size(); ++f) {
516 const Field& field = fieldset[f];
517 if (field.datatype() == array::DataType::kind<int>()) {
518 if (field.levels()) {
519 md5 << checksum_3d_field<int>(checksum(), field);
520 }
521 else {
522 md5 << checksum_2d_field<int>(checksum(), field);
523 }
524 }
525 else if (field.datatype() == array::DataType::kind<long>()) {
526 if (field.levels()) {
527 md5 << checksum_3d_field<long>(checksum(), field);
528 }
529 else {
530 md5 << checksum_2d_field<long>(checksum(), field);
531 }
532 }
533 else if (field.datatype() == array::DataType::kind<float>()) {
534 if (field.levels()) {
535 md5 << checksum_3d_field<float>(checksum(), field);
536 }
537 else {
538 md5 << checksum_2d_field<float>(checksum(), field);
539 }
540 }
541 else if (field.datatype() == array::DataType::kind<double>()) {
542 if (field.levels()) {
543 md5 << checksum_3d_field<double>(checksum(), field);
544 }
545 else {
546 md5 << checksum_2d_field<double>(checksum(), field);
547 }
548 }
549 else {
550 throw_Exception("datatype not supported", Here());
551 }
552 }
553 return md5;
554 }
555 std::string EdgeColumns::checksum(const Field& field) const {
556 FieldSet fieldset;
557 fieldset.add(field);
558 return checksum(fieldset);
559 }
560
561 const parallel::Checksum& EdgeColumns::checksum() const {
562 if (checksum_) {
563 return *checksum_;
564 }
565 checksum_ = EdgeColumnsChecksumCache::instance().get_or_create(mesh_);
566 return *checksum_;
567 }
568
569 const Grid& EdgeColumns::grid() const {
570 if (grid_) {
571 return grid_;
572 }
573
574 const auto& comm = mpi::comm(mpi_comm());
575 std::vector<PointXY> points;
576 if (comm.size() == 1) {
577 const auto xy = atlas::array::make_view<double, 2>(mesh_.nodes().xy());
578 for (auto i = 0; i < xy.shape(0); i++) {
579 points.push_back({xy(i, 0), xy(i, 1)});
580 }
581 } else {
582 std::vector<int> gidx;
583 std::vector<double> x, y;
584 const auto gidxView = array::make_view<gidx_t, 1>(global_index());
585 const auto ghostView = array::make_view<int, 1>(ghost());
586 const auto xy = atlas::array::make_view<double, 2>(mesh_.nodes().xy());
587 for (auto i = 0; i < xy.shape(0); i++) {
588 if (ghostView(i) == 0) {
589 gidx.push_back(gidxView(i));
590 x.push_back(xy(i, 0));
591 y.push_back(xy(i, 1));
592 }
593 }
594 eckit::mpi::Buffer<int> gidxBuffer(comm.size());
595 eckit::mpi::Buffer<double> xBuffer(comm.size());
596 eckit::mpi::Buffer<double> yBuffer(comm.size());
597 comm.allGatherv(gidx.begin(), gidx.end(), gidxBuffer);
598 comm.allGatherv(x.begin(), x.end(), xBuffer);
599 comm.allGatherv(y.begin(), y.end(), yBuffer);
600 points.reserve(gidxBuffer.buffer.size());
601 for (auto i : gidxBuffer.buffer) {
602 points[i - 1] = atlas::PointXY{xBuffer.buffer[i - 1], yBuffer.buffer[i - 1]};
603 }
604 }
605 grid_ = UnstructuredGrid(points);
606 return grid_;
607 }
608
609 Field EdgeColumns::lonlat() const {
610 return edges().field("lonlat");
611 }
612
613 Field EdgeColumns::global_index() const {
614 return edges().global_index();
615 };
616
617 Field EdgeColumns::remote_index() const {
618 return edges().remote_index();
619 };
620
621 Field EdgeColumns::partition() const {
622 return edges().partition();
623 }
624
625 //------------------------------------------------------------------------------
626 //------------------------------------------------------------------------------
627 //------------------------------------------------------------------------------
628 extern "C" {
629 //------------------------------------------------------------------------------
630 //------------------------------------------------------------------------------
631 //------------------------------------------------------------------------------
632
633 EdgeColumns* atlas__fs__EdgeColumns__new(Mesh::Implementation* mesh, const eckit::Configuration* config) {
634 ATLAS_ASSERT(mesh != nullptr);
635 Mesh m(mesh);
636 return new EdgeColumns(m, *config);
637 }
638
639 //------------------------------------------------------------------------------
640
641 void atlas__fs__EdgeColumns__delete(EdgeColumns* This) {
642 ATLAS_ASSERT(This != nullptr);
643 delete (This);
644 }
645
646 //------------------------------------------------------------------------------
647
648 int atlas__fs__EdgeColumns__nb_edges(const EdgeColumns* This) {
649 ATLAS_ASSERT(This != nullptr);
650 return This->nb_edges();
651 }
652
653 //------------------------------------------------------------------------------
654
655 Mesh::Implementation* atlas__fs__EdgeColumns__mesh(EdgeColumns* This) {
656 ATLAS_ASSERT(This != nullptr);
657 return This->mesh().get();
658 }
659
660 //------------------------------------------------------------------------------
661
662 mesh::Edges* atlas__fs__EdgeColumns__edges(EdgeColumns* This) {
663 ATLAS_ASSERT(This != nullptr);
664 return &This->edges();
665 }
666
667 //------------------------------------------------------------------------------
668
669 using field::FieldImpl;
670 using field::FieldSetImpl;
671
672 field::FieldImpl* atlas__fs__EdgeColumns__create_field(const EdgeColumns* This, const eckit::Configuration* options) {
673 ATLAS_ASSERT(This);
674 ATLAS_ASSERT(options);
675 FieldImpl* field;
676 {
677 Field f = This->createField(*options);
678 field = f.get();
679 field->attach();
680 }
681 field->detach();
682 return field;
683 }
684
685 //------------------------------------------------------------------------------
686
687 field::FieldImpl* atlas__fs__EdgeColumns__create_field_template(const EdgeColumns* This,
688 const field::FieldImpl* field_template,
689 const eckit::Configuration* options) {
690 ATLAS_ASSERT(This);
691 ATLAS_ASSERT(options);
692 FieldImpl* field;
693 {
694 Field f = This->createField(Field(field_template), *options);
695 field = f.get();
696 field->attach();
697 }
698 field->detach();
699 return field;
700 }
701
702 // -----------------------------------------------------------------------------------
703
704 void atlas__fs__EdgeColumns__halo_exchange_fieldset(const EdgeColumns* This, field::FieldSetImpl* fieldset) {
705 ATLAS_ASSERT(This != nullptr);
706 ATLAS_ASSERT(fieldset != nullptr);
707 FieldSet f(fieldset);
708 This->haloExchange(f);
709 }
710
711 // -----------------------------------------------------------------------------------
712
713 void atlas__fs__EdgeColumns__halo_exchange_field(const EdgeColumns* This, field::FieldImpl* field) {
714 ATLAS_ASSERT(This != nullptr);
715 ATLAS_ASSERT(field != nullptr);
716 Field f(field);
717 This->haloExchange(f);
718 }
719
720 // -----------------------------------------------------------------------------------
721
722 const parallel::HaloExchange* atlas__fs__EdgeColumns__get_halo_exchange(const EdgeColumns* This) {
723 ATLAS_ASSERT(This != nullptr);
724 return &This->halo_exchange();
725 }
726
727 // -----------------------------------------------------------------------------------
728
729 void atlas__fs__EdgeColumns__gather_fieldset(const EdgeColumns* This, const field::FieldSetImpl* local,
730 field::FieldSetImpl* global) {
731 ATLAS_ASSERT(This);
732 ATLAS_ASSERT(local);
733 ATLAS_ASSERT(global);
734 const FieldSet l(local);
735 FieldSet g(global);
736 This->gather(l, g);
737 }
738
739 // -----------------------------------------------------------------------------------
740
741 void atlas__fs__EdgeColumns__gather_field(const EdgeColumns* This, const field::FieldImpl* local,
742 field::FieldImpl* global) {
743 ATLAS_ASSERT(This);
744 ATLAS_ASSERT(local);
745 ATLAS_ASSERT(global);
746 const Field l(local);
747 Field g(global);
748 This->gather(l, g);
749 }
750
751 // -----------------------------------------------------------------------------------
752
753 const parallel::GatherScatter* atlas__fs__EdgeColumns__get_gather(const EdgeColumns* This) {
754 ATLAS_ASSERT(This);
755 return &This->gather();
756 }
757
758 // -----------------------------------------------------------------------------------
759
760 const parallel::GatherScatter* atlas__fs__EdgeColumns__get_scatter(const EdgeColumns* This) {
761 ATLAS_ASSERT(This);
762 return &This->scatter();
763 }
764
765 // -----------------------------------------------------------------------------------
766
767 void atlas__fs__EdgeColumns__scatter_fieldset(const EdgeColumns* This, const field::FieldSetImpl* global,
768 field::FieldSetImpl* local) {
769 ATLAS_ASSERT(This);
770 ATLAS_ASSERT(local);
771 ATLAS_ASSERT(global);
772 const FieldSet g(global);
773 FieldSet l(local);
774 This->scatter(g, l);
775 }
776
777 // -----------------------------------------------------------------------------------
778
779 void atlas__fs__EdgeColumns__scatter_field(const EdgeColumns* This, const field::FieldImpl* global,
780 field::FieldImpl* local) {
781 ATLAS_ASSERT(This);
782 ATLAS_ASSERT(global);
783 ATLAS_ASSERT(local);
784 const Field g(global);
785 Field l(local);
786 This->scatter(g, l);
787 }
788
789 // -----------------------------------------------------------------------------------
790
791 const parallel::Checksum* atlas__fs__EdgeColumns__get_checksum(const EdgeColumns* This) {
792 ATLAS_ASSERT(This);
793 return &This->checksum();
794 }
795
796 // -----------------------------------------------------------------------------------
797
798 void atlas__fs__EdgeColumns__checksum_fieldset(const EdgeColumns* This, const field::FieldSetImpl* fieldset,
799 char*& checksum, int& size, int& allocated) {
800 ATLAS_ASSERT(This);
801 ATLAS_ASSERT(fieldset);
802 std::string checksum_str(This->checksum(fieldset));
803 size = static_cast<int>(checksum_str.size());
804 checksum = new char[size + 1];
805 allocated = true;
806 std::strncpy(checksum, checksum_str.c_str(), size + 1);
807 }
808
809 // -----------------------------------------------------------------------------------
810
811 void atlas__fs__EdgeColumns__checksum_field(const EdgeColumns* This, const field::FieldImpl* field, char*& checksum,
812 int& size, int& allocated) {
813 ATLAS_ASSERT(This);
814 ATLAS_ASSERT(field);
815 std::string checksum_str(This->checksum(field));
816 size = static_cast<int>(checksum_str.size());
817 checksum = new char[size + 1];
818 allocated = true;
819 std::strncpy(checksum, checksum_str.c_str(), size + 1);
820 }
821 }
822
823 // -----------------------------------------------------------------------------------
824
825 } // namespace detail
826
827 // -----------------------------------------------------------------------------------
828
829 EdgeColumns::EdgeColumns(): FunctionSpace(), functionspace_(nullptr) {}
830
831 EdgeColumns::EdgeColumns(const FunctionSpace& functionspace):
832 FunctionSpace(functionspace), functionspace_(dynamic_cast<const detail::EdgeColumns*>(get())) {}
833
834 EdgeColumns::EdgeColumns(const Mesh& mesh, const eckit::Configuration& config):
835 FunctionSpace(new detail::EdgeColumns(mesh, config)),
836 functionspace_(dynamic_cast<const detail::EdgeColumns*>(get())) {}
837
838 EdgeColumns::EdgeColumns(const Mesh& mesh):
839 FunctionSpace(new detail::EdgeColumns(mesh)), functionspace_(dynamic_cast<const detail::EdgeColumns*>(get())) {}
840
841 idx_t EdgeColumns::nb_edges() const {
842 return functionspace_->nb_edges();
843 }
844
845 idx_t EdgeColumns::nb_edges_global() const { // Only on MPI rank 0, will this be different from 0
846 return functionspace_->nb_edges_global();
847 }
848
849 const Mesh& EdgeColumns::mesh() const {
850 return functionspace_->mesh();
851 }
852
853 const mesh::HybridElements& EdgeColumns::edges() const {
854 return functionspace_->edges();
855 }
856
857 const parallel::HaloExchange& EdgeColumns::halo_exchange() const {
858 return functionspace_->halo_exchange();
859 }
860
861 std::string EdgeColumns::checksum(const FieldSet& fieldset) const {
862 return functionspace_->checksum(fieldset);
863 }
864
865 std::string EdgeColumns::checksum(const Field& field) const {
866 return functionspace_->checksum(field);
867 }
868
869 const parallel::Checksum& EdgeColumns::checksum() const {
870 return functionspace_->checksum();
871 }
872
873 } // namespace functionspace
874 } // namespace atlas