Debian Codegraph @

src/atlas/mesh/Connectivity.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 <limits>
13 #include <ostream>
14
15 #include "eckit/io/Buffer.h"
16 #include "eckit/serialisation/Stream.h"
17
18 #include "atlas/array.h"
19 #include "atlas/array/DataType.h"
20 #include "atlas/array/MakeView.h"
21 #include "atlas/library/config.h"
22 #include "atlas/mesh/Connectivity.h"
23 #include "atlas/runtime/Exception.h"
24
25 #if ATLAS_HAVE_FORTRAN
26 #define FORTRAN_BASE 1
27 #define TO_FORTRAN +1
28 #else
29 #define FORTRAN_BASE 0
30 #define TO_FORTRAN
31 #endif
32
33 namespace atlas {
34 namespace mesh {
35 // -----------------------------------------------------------------------------
36
37 IrregularConnectivityImpl::IrregularConnectivityImpl(const std::string& name):
38 owns_(true),
39 values_(0),
40 displs_(1),
41 counts_(1),
42 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()),
43 rows_(0),
44 maxcols_(0),
45 mincols_(std::numeric_limits<idx_t>::max()),
46 ctxt_(nullptr),
47 callback_update_(nullptr),
48 callback_delete_(nullptr) {
49 rename(name);
50 displs_[0] = 0;
51 counts_[0] = 0;
52 }
53
54 // -----------------------------------------------------------------------------
55
56 idx_t get_total_size_counts(idx_t rows, idx_t counts[]) {
57 idx_t total_size = 0;
58 for (idx_t j = 0; j < rows; ++j) {
59 total_size += counts[j];
60 }
61 return total_size;
62 }
63
64 // -----------------------------------------------------------------------------
65
66 IrregularConnectivityImpl::IrregularConnectivityImpl(idx_t values[], idx_t rows, idx_t displs[], idx_t counts[]):
67 owns_(false),
68 //TODO need to create clone if pointers are not cuda managed
69 values_(values, get_total_size_counts(rows, counts)),
70 displs_(displs, rows),
71 counts_(counts, rows),
72 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()),
73 rows_(rows),
74 ctxt_(nullptr),
75 callback_update_(nullptr),
76 callback_delete_(nullptr) {
77 maxcols_ = 0;
78 mincols_ = std::numeric_limits<idx_t>::max();
79 for (idx_t j = 0; j < rows; ++j) {
80 maxcols_ = std::max(maxcols_, counts[j]);
81 mincols_ = std::min(mincols_, counts[j]);
82 }
83 }
84
85 //------------------------------------------------------------------------------------------------------
86
87 IrregularConnectivityImpl::IrregularConnectivityImpl(eckit::Stream& s) {
88 decode_(s);
89 }
90
91 //------------------------------------------------------------------------------------------------------
92
93 IrregularConnectivityImpl::~IrregularConnectivityImpl() {
94 on_delete();
95 //TODO owns is unsed ?
96 }
97
98 //------------------------------------------------------------------------------------------------------
99
100 void IrregularConnectivityImpl::clear() {
101 //TODO clean this
102 if (owns()) {
103 values_.resize(0);
104 displs_.resize(1);
105 counts_.resize(1);
106 displs_(0) = 0;
107 counts_(0) = 0;
108 }
109 else {
110 //TODO what to do here
111 // data_[_values_] = nullptr;
112 // data_[_displs_] = nullptr;
113 // data_[_counts_] = nullptr;
114 // std::for_each(data_.begin(), data_.end(), [](array::Array* a){ a=0;});
115 }
116 rows_ = 0;
117 maxcols_ = 0;
118 mincols_ = std::numeric_limits<idx_t>::max();
119 on_update();
120 }
121
122 //------------------------------------------------------------------------------------------------------
123
124 void IrregularConnectivityImpl::on_delete() {
125 if (ctxt_ && callback_delete_) {
126 callback_delete_(ctxt_);
127 }
128 }
129
130 //------------------------------------------------------------------------------------------------------
131
132 void IrregularConnectivityImpl::on_update() {
133 if (ctxt_ && callback_update_) {
134 callback_update_(ctxt_);
135 }
136 }
137
138 void IrregularConnectivityImpl::resize(idx_t old_size, idx_t new_size, bool initialize, const idx_t values[],
139 bool fortran_array) {
140 values_.resize(new_size);
141
142 idx_t add_base = fortran_array ? 0 : FORTRAN_BASE;
143 if (initialize) {
144 for (idx_t j = 0, c = old_size; c < new_size; ++c, ++j) {
145 values_[c] = values[j] + add_base;
146 }
147 }
148 else {
149 for (idx_t j = old_size; j < new_size; ++j) {
150 values_[j] = missing_value() TO_FORTRAN;
151 }
152 }
153 }
154
155 //------------------------------------------------------------------------------------------------------
156 void IrregularConnectivityImpl::add(idx_t rows, idx_t cols, const idx_t values[], bool fortran_array) {
157 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
158 idx_t old_size = values_.size();
159
160 if (rows_ == 0) {
161 old_size = 0;
162 }
163
164 idx_t new_size = old_size + rows * cols;
165 idx_t new_rows = rows_ + rows;
166
167 //TODO what to do here
168 // ATLAS_ASSERT( displs_] != nullptr );
169 // ATLAS_ASSERT( data_[_counts_] != nullptr );
170 displs_.resize(new_rows + 1);
171 counts_.resize(new_rows);
172
173 for (idx_t j = 0; rows_ < new_rows; ++rows_, ++j) {
174 displs_[rows_ + 1] = displs_[rows_] + cols;
175 counts_[rows_] = cols;
176 }
177
178 maxcols_ = std::max(maxcols_, cols);
179 mincols_ = std::min(mincols_, cols);
180
181 resize(old_size, new_size, true, values, fortran_array);
182
183 on_update();
184 }
185
186 //------------------------------------------------------------------------------------------------------
187
188 void IrregularConnectivityImpl::add(const BlockConnectivityImpl& block) {
189 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
190 bool fortran_array = FORTRAN_BASE;
191 const idx_t rows = block.rows();
192 const idx_t cols = block.cols();
193 const idx_t* values = block.data();
194
195 add(rows, cols, values, fortran_array);
196 }
197
198 //------------------------------------------------------------------------------------------------------
199
200 void IrregularConnectivityImpl::add(idx_t rows, const idx_t cols[]) {
201 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
202 idx_t old_size = values_.size();
203 idx_t new_size = old_size;
204 for (idx_t j = 0; j < rows; ++j) {
205 new_size += cols[j];
206 }
207 idx_t new_rows = rows_ + rows;
208 displs_.resize(new_rows + 1);
209 counts_.resize(new_rows);
210
211 for (idx_t j = 0; rows_ < new_rows; ++rows_, ++j) {
212 displs_[rows_ + 1] = displs_[rows_] + cols[j];
213 counts_[rows_] = cols[j];
214 maxcols_ = std::max(maxcols_, cols[j]);
215 mincols_ = std::min(mincols_, cols[j]);
216 }
217
218 resize(old_size, new_size, false, nullptr, false);
219
220 on_update();
221 }
222
223 //------------------------------------------------------------------------------------------------------
224
225 void IrregularConnectivityImpl::add(idx_t rows, idx_t cols) {
226 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
227 idx_t old_size = values_.size();
228
229 if (rows_ == 0) {
230 old_size = 0;
231 }
232
233 idx_t new_size = old_size + rows * cols;
234 idx_t new_rows = rows_ + rows;
235
236 //TODO
237 // ATLAS_ASSERT( data_[_displs_] != nullptr );
238 // ATLAS_ASSERT( data_[_counts_] != nullptr );
239 displs_.resize(new_rows + 1);
240 counts_.resize(new_rows);
241
242 for (idx_t j = 0; rows_ < new_rows; ++rows_, ++j) {
243 displs_[rows_ + 1] = displs_[rows_] + cols;
244 counts_[rows_] = cols;
245 }
246
247 maxcols_ = std::max(maxcols_, cols);
248 mincols_ = std::min(mincols_, cols);
249
250 const bool dummy_arg_fortran_array = false;
251 const idx_t* dummy_arg_values = nullptr;
252 resize(old_size, new_size, false, dummy_arg_values, dummy_arg_fortran_array);
253
254 on_update();
255 }
256
257 //------------------------------------------------------------------------------------------------------
258
259 void IrregularConnectivityImpl::insert(idx_t position, idx_t rows, idx_t cols, const idx_t values[],
260 bool fortran_array) {
261 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
262 idx_t position_displs = displs_[position];
263 displs_.insert(position, rows);
264 counts_.insert(position, rows);
265
266 displs_[position] = position_displs;
267 for (idx_t jrow = position; jrow < position + rows; ++jrow) {
268 counts_[jrow] = cols;
269 }
270 for (idx_t jrow = position; jrow < displs_.size() - 1; ++jrow) {
271 displs_[jrow + 1] = displs_[jrow] + counts_[jrow];
272 }
273 maxcols_ = std::max(maxcols_, cols);
274 mincols_ = std::min(mincols_, cols);
275
276 values_.insert(position_displs, rows * cols);
277
278 if (values == nullptr) {
279 for (idx_t c = position_displs; c < position_displs + rows * cols; ++c) {
280 values_[c] = missing_value() TO_FORTRAN;
281 }
282 }
283 else {
284 idx_t add_base = fortran_array ? 0 : FORTRAN_BASE;
285 for (idx_t c = position_displs; c < position_displs + rows * cols; ++c) {
286 values_[c] = values[c - position_displs] + add_base;
287 }
288 }
289 rows_ += rows;
290
291 on_update();
292 }
293
294 //------------------------------------------------------------------------------------------------------
295
296 void IrregularConnectivityImpl::insert(idx_t position, idx_t rows, idx_t cols) {
297 IrregularConnectivityImpl::insert(position, rows, cols, nullptr, false);
298 }
299
300 //------------------------------------------------------------------------------------------------------
301
302 void IrregularConnectivityImpl::insert(idx_t position, idx_t rows, const idx_t cols[]) {
303 ATLAS_ASSERT(owns_, "Connectivity must be owned to be resized directly");
304 idx_t position_displs = displs_[position];
305
306 if (rows_ == 0) {
307 if (position > 1) {
308 displs_.insert(position - 1, rows);
309 counts_.insert(position - 1, rows);
310 }
311 }
312 else {
313 displs_.insert(position, rows);
314 counts_.insert(position, rows);
315 }
316
317 displs_[position] = position_displs;
318 for (idx_t jrow = position; jrow < position + rows; ++jrow) {
319 counts_[jrow] = cols[jrow - position];
320 maxcols_ = std::max(maxcols_, counts_[jrow]);
321 mincols_ = std::min(mincols_, counts_[jrow]);
322 }
323 for (idx_t jrow = position; jrow < displs_.size() - 1; ++jrow) {
324 displs_[jrow + 1] = displs_[jrow] + counts_[jrow];
325 }
326
327 idx_t insert_size(0);
328 for (idx_t j = 0; j < rows; ++j) {
329 insert_size += cols[j];
330 }
331
332 values_.insert(position_displs, insert_size);
333
334 for (idx_t c = position_displs; c < position_displs + insert_size; ++c) {
335 values_[c] = missing_value() TO_FORTRAN;
336 }
337
338 rows_ += rows;
339 on_update();
340 }
341
342 size_t IrregularConnectivityImpl::footprint() const {
343 size_t size = sizeof(*this);
344 size += values_.footprint();
345 size += displs_.footprint();
346 size += counts_.footprint();
347 return size;
348 }
349
350 void IrregularConnectivityImpl::dump(std::ostream& os) const {
351 //TODO dump
352 }
353
354 eckit::Stream& operator>>(eckit::Stream& s, array::SVector<idx_t>& x) {
355 size_t size;
356 s >> size;
357 eckit::Buffer buffer(size * sizeof(idx_t));
358 s >> buffer;
359 idx_t* data = static_cast<idx_t*>(buffer.data());
360 idx_t N = static_cast<idx_t>(size);
361 x.resize(N);
362 for (idx_t i = 0; i < N; ++i) {
363 x(i) = data[i];
364 }
365 return s;
366 }
367
368 eckit::Stream& operator<<(eckit::Stream& s, const array::SVector<idx_t>& x) {
369 size_t size = x.size();
370 s << size;
371 eckit::Buffer buffer(reinterpret_cast<const char*>(x.data()), size * sizeof(idx_t));
372 s << buffer;
373 return s;
374 }
375
376 void BlockConnectivityImpl::print(std::ostream& out) const {
377 out << "BlockConnectivity:{rows:" << rows_ << ",cols:" << cols_ << ",values:";
378 if (values_.size() == 0) {
379 out << "null";
380 }
381 else {
382 out << "[";
383 for (idx_t i = 0; i < values_.size(); ++i) {
384 out << values_[i] << (i < values_.size() - 1 ? "," : "]");
385 }
386 }
387 out << "}";
388 }
389
390
391 void IrregularConnectivityImpl::encode_(eckit::Stream& s) const {
392 s << name();
393 s << values_;
394 s << displs_;
395 s << counts_;
396 s << missing_value_;
397 s << rows_;
398 s << maxcols_;
399 s << mincols_;
400 }
401
402
403 void IrregularConnectivityImpl::decode_(eckit::Stream& s) {
404 std::string name;
405 s >> name;
406 s >> values_;
407 s >> displs_;
408 s >> counts_;
409 s >> missing_value_;
410 s >> rows_;
411 s >> maxcols_;
412 s >> mincols_;
413 if (not name.empty()) {
414 rename(name);
415 }
416 ctxt_ = nullptr;
417 owns_ = true;
418 }
419
420 //------------------------------------------------------------------------------------------------------
421 /*
422 }
423
424 //------------------------------------------------------------------------------------------------------
425
426 MultiBlockConnectivity::MultiBlockConnectivity( idx_t values[], idx_t rows,
427 idx_t displs[], idx_t counts[], idx_t blocks, idx_t block_displs[], idx_t
428 block_cols[] )
429 : IrregularConnectivity(values,rows,displs,counts),
430 blocks_(blocks),
431 block_displs_(array::Array::wrap<idx_t>(block_displs,
432 array::ArrayShape{blocks})),
433 block_cols_(array::Array::wrap<idx_t>(block_cols,
434 array::ArrayShape{blocks})),
435 block_(blocks),
436 block_displs_view_(array::make_view<idx_t, 1>(*block_displs_)),
437 block_cols_view_(array::make_view<idx_t, 1>(*block_cols_))
438 {
439 rebuild_block_connectivity();
440 }
441 */
442 //------------------------------------------------------------------------------------------------------
443
444 MultiBlockConnectivityImpl::MultiBlockConnectivityImpl(const std::string& name):
445 IrregularConnectivityImpl(name), blocks_(0), block_displs_(1), block_cols_(1), block_(0) {
446 block_displs_(0) = 0;
447 }
448
449 MultiBlockConnectivityImpl::MultiBlockConnectivityImpl(eckit::Stream& s): IrregularConnectivityImpl(s) {
450 decode_(s);
451 }
452
453 //------------------------------------------------------------------------------------------------------
454
455 MultiBlockConnectivityImpl::~MultiBlockConnectivityImpl() = default;
456
457 //------------------------------------------------------------------------------------------------------
458
459 void MultiBlockConnectivityImpl::clear() {
460 IrregularConnectivityImpl::clear();
461 if (owns()) {
462 block_displs_.resize(1);
463 block_cols_.resize(1);
464 block_displs_(0) = 0ul;
465 }
466 blocks_ = 0;
467 block_.clear();
468 }
469
470 //------------------------------------------------------------------------------------------------------
471
472 void MultiBlockConnectivityImpl::add(idx_t rows, idx_t cols, const idx_t values[], bool fortran_array) {
473 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
474 idx_t old_rows = this->rows();
475 IrregularConnectivityImpl::add(rows, cols, values, fortran_array);
476
477 for (idx_t b = 0; b < blocks_; ++b) {
478 ATLAS_ASSERT(block_[b].owns() == false);
479 }
480
481 block_displs_.insert(block_displs_.size(), 1);
482 block_cols_.insert(block_cols_.size(), 1);
483
484 blocks_++;
485 block_displs_[block_displs_.size() - 1] = old_rows + rows;
486 block_cols_[block_cols_.size() - 2] = cols;
487
488 rebuild_block_connectivity();
489 }
490
491 //------------------------------------------------------------------------------------------------------
492
493 void MultiBlockConnectivityImpl::add(const BlockConnectivityImpl& block) {
494 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
495 IrregularConnectivityImpl::add(block);
496 }
497
498 //------------------------------------------------------------------------------------------------------
499
500 void MultiBlockConnectivityImpl::add(idx_t rows, idx_t cols) {
501 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
502 idx_t old_rows = this->rows();
503 IrregularConnectivityImpl::add(rows, cols);
504
505 for (idx_t b = 0; b < blocks_; ++b) {
506 ATLAS_ASSERT(block_[b].owns() == false);
507 }
508
509
510 block_displs_.insert(block_displs_.size(), 1);
511 block_cols_.insert(block_cols_.size(), 1);
512 blocks_++;
513
514 block_displs_[block_displs_.size() - 1] = old_rows + rows;
515 block_cols_[block_cols_.size() - 2] = cols;
516
517 rebuild_block_connectivity();
518 }
519
520 //------------------------------------------------------------------------------------------------------
521
522 void MultiBlockConnectivityImpl::add(idx_t rows, const idx_t cols[]) {
523 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
524 idx_t min = std::numeric_limits<idx_t>::max();
525 idx_t max = 0;
526 idx_t old_rows = this->rows();
527
528 for (idx_t j = 0; j < rows; ++j) {
529 min = std::min(min, cols[j]);
530 max = std::min(max, cols[j]);
531 }
532 ATLAS_ASSERT(min == max,
533 "MultiBlockConnectivity::add(rows,cols[]): "
534 "all elements of cols[] must be identical");
535 IrregularConnectivityImpl::add(rows, cols);
536
537 for (idx_t b = 0; b < blocks_; ++b) {
538 ATLAS_ASSERT(block_[b].owns() == false);
539 }
540
541 block_displs_.insert(block_displs_.size(), 1);
542 block_cols_.insert(block_cols_.size(), 1);
543 blocks_++;
544 block_displs_(block_displs_.size() - 1) = old_rows;
545 block_cols_[block_cols_.size() - 2] = max;
546
547 rebuild_block_connectivity();
548 }
549
550 //------------------------------------------------------------------------------------------------------
551
552 void MultiBlockConnectivityImpl::insert(idx_t position, idx_t rows, idx_t cols, const idx_t values[],
553 bool fortran_array) {
554 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
555
556 ATLAS_ASSERT(blocks_);
557
558 long blk_idx = blocks_;
559 do {
560 blk_idx--;
561 } while (blk_idx >= 0l && block_displs_[blk_idx] >= position && cols != block_cols_[blk_idx]);
562 ATLAS_ASSERT(blk_idx >= 0l);
563 ATLAS_ASSERT(cols == block(blk_idx).cols());
564
565 for (idx_t jblk = blk_idx; jblk < blocks_; ++jblk) {
566 block_displs_[jblk + 1] += rows;
567 }
568
569 IrregularConnectivityImpl::insert(position, rows, cols, values, fortran_array);
570 rebuild_block_connectivity();
571 }
572
573 //------------------------------------------------------------------------------------------------------
574
575 void MultiBlockConnectivityImpl::insert(idx_t position, idx_t rows, idx_t cols) {
576 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
577
578 long blk_idx = blocks_;
579 do {
580 blk_idx--;
581 } while (blk_idx >= 0l && block_displs_[blk_idx] >= position && cols != block_cols_[blk_idx]);
582
583 ATLAS_ASSERT(blk_idx >= 0l);
584
585 for (idx_t b = 0; b < blocks_; ++b) {
586 ATLAS_ASSERT(block_[b].owns() == false);
587 }
588
589 IrregularConnectivityImpl::insert(position, rows, cols);
590
591 for (idx_t jblk = blk_idx; jblk < blocks_; ++jblk) {
592 block_displs_[jblk + 1] += rows;
593 }
594 rebuild_block_connectivity();
595 }
596
597 //------------------------------------------------------------------------------------------------------
598
599 void MultiBlockConnectivityImpl::insert(idx_t position, idx_t rows, const idx_t cols[]) {
600 ATLAS_ASSERT(owns(), "MultiBlockConnectivity must be owned to be resized directly");
601
602 idx_t min = std::numeric_limits<idx_t>::max();
603 idx_t max = 0;
604 for (idx_t j = 0; j < rows; ++j) {
605 min = std::min(min, cols[j]);
606 max = std::min(max, cols[j]);
607 }
608 ATLAS_ASSERT(min == max,
609 "MultiBlockConnectivity::add(rows,cols[]): "
610 "all elements of cls[] must be identical");
611
612 long blk_idx = blocks_;
613 do {
614 blk_idx--;
615 } while (blk_idx >= 0l && block_displs_[blk_idx] >= position && max != block_cols_[blk_idx]);
616
617 ATLAS_ASSERT(blk_idx >= 0l);
618
619 IrregularConnectivityImpl::insert(position, rows, cols);
620
621 for (idx_t jblk = blk_idx; jblk < blocks_; ++jblk) {
622 block_displs_[jblk + 1] += rows;
623 }
624 rebuild_block_connectivity();
625 }
626
627 //------------------------------------------------------------------------------------------------------
628
629 void MultiBlockConnectivityImpl::rebuild_block_connectivity() {
630 block_.resize(blocks_);
631
632 for (idx_t b = 0; b < blocks_; ++b) {
633 block_[b].rebuild(block_displs_[b + 1] - block_displs_[b], // rows
634 block_cols_[b], // cols
635 values_.data() + displs(block_displs_[b]));
636 }
637 }
638
639 //------------------------------------------------------------------------------------------------------
640
641 size_t MultiBlockConnectivityImpl::footprint() const {
642 size_t size = IrregularConnectivityImpl::footprint();
643 size += block_displs_.footprint();
644 size += block_cols_.footprint();
645
646 for (idx_t j = 0; j < block_.size(); ++j) {
647 size += block_[j].footprint();
648 }
649 return size;
650 }
651
652 //------------------------------------------------------------------------------------------------------
653
654 void MultiBlockConnectivityImpl::encode_(eckit::Stream& s) const {
655 s << blocks_;
656 s << block_displs_;
657 s << block_cols_;
658 }
659
660 //------------------------------------------------------------------------------------------------------
661
662 void MultiBlockConnectivityImpl::decode_(eckit::Stream& s) {
663 s >> blocks_;
664 s >> block_displs_;
665 s >> block_cols_;
666 rebuild_block_connectivity();
667 }
668
669 //------------------------------------------------------------------------------------------------------
670
671 BlockConnectivityImpl::BlockConnectivityImpl():
672 owns_(true),
673 values_(0),
674 rows_(0),
675 cols_(0),
676 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()) {}
677
678 //------------------------------------------------------------------------------------------------------
679
680 BlockConnectivityImpl::BlockConnectivityImpl(idx_t rows, idx_t cols, const std::initializer_list<idx_t>& values):
681 owns_(true),
682 values_(rows * cols),
683 rows_(rows),
684 cols_(cols),
685 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()) {
686 idx_t add_base = FORTRAN_BASE;
687 auto v = values.begin();
688 for (idx_t i = 0; i < rows_; ++i) {
689 for (idx_t j = 0; j < cols_; ++j) {
690 values_[index(i, j)] = *(v++) + add_base;
691 }
692 }
693 ATLAS_ASSERT(v == values.end());
694 }
695
696 //------------------------------------------------------------------------------------------------------
697
698 BlockConnectivityImpl::BlockConnectivityImpl(idx_t rows, idx_t cols, idx_t values[]):
699 owns_(true),
700 values_(rows * cols),
701 rows_(rows),
702 cols_(cols),
703 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()) {
704 if (values_.size()) {
705 idx_t add_base = FORTRAN_BASE;
706 idx_t* v = &values[0];
707 for (idx_t i = 0; i < rows_; ++i) {
708 for (idx_t j = 0; j < cols_; ++j) {
709 values_[index(i, j)] = *(v++) + add_base;
710 }
711 }
712 }
713 }
714
715 BlockConnectivityImpl::BlockConnectivityImpl(eckit::Stream& s) {
716 decode(s);
717 }
718
719 //------------------------------------------------------------------------------------------------------
720
721 BlockConnectivityImpl::BlockConnectivityImpl(idx_t rows, idx_t cols, idx_t values[], bool /*dummy*/):
722 owns_(false),
723 values_(values, rows * cols),
724 rows_(rows),
725 cols_(cols),
726 missing_value_(std::numeric_limits<idx_t>::is_signed ? -1 : std::numeric_limits<idx_t>::max()) {}
727
728 //------------------------------------------------------------------------------------------------------
729
730 BlockConnectivityImpl::BlockConnectivityImpl(BlockConnectivityImpl&& other):
731 owns_(other.owns_),
732 values_(std::move(other.values_)),
733 rows_(other.rows_),
734 cols_(other.cols_),
735 missing_value_(other.missing_value_) {
736 other.owns_ = false;
737 rows_ = 0;
738 cols_ = 0;
739 }
740
741 BlockConnectivityImpl& BlockConnectivityImpl::operator=(BlockConnectivityImpl&& other) {
742 owns_ = other.owns_;
743 values_ = std::move(other.values_);
744 rows_ = other.rows_;
745 cols_ = other.cols_;
746 missing_value_ = other.missing_value_;
747 other.owns_ = false;
748 other.rows_ = 0;
749 other.cols_ = 0;
750 return *this;
751 }
752
753
754 BlockConnectivityImpl::~BlockConnectivityImpl() {
755 values_.clear();
756 }
757
758 //------------------------------------------------------------------------------------------------------
759
760 void BlockConnectivityImpl::rebuild(idx_t rows, idx_t cols, idx_t values[]) {
761 owns_ = false;
762 rows_ = rows;
763 cols_ = cols;
764 values_ = array::SVector<idx_t>(values, rows * cols);
765 }
766
767 //------------------------------------------------------------------------------------------------------
768
769 void BlockConnectivityImpl::add(idx_t rows, idx_t cols, const idx_t values[], bool fortran_array) {
770 ATLAS_ASSERT(owns(), "BlockConnectivity must be owned to be resized directly");
771 if (cols_ != 0 && cols_ != cols) {
772 ATLAS_ASSERT(false,
773 "Cannot add values with different cols than "
774 "already existing in BlockConnectivity");
775 }
776
777 values_.resize((rows_ + rows) * cols);
778 const idx_t oldrows = rows_;
779 idx_t add_base = fortran_array ? 0 : FORTRAN_BASE;
780
781 rows_ += rows;
782 cols_ = cols;
783
784 for (idx_t i = 0; i < rows; ++i) {
785 for (idx_t j = 0; j < cols; ++j) {
786 values_[index(i + oldrows, j)] = values[i * cols + j] + add_base;
787 }
788 }
789 }
790
791 void BlockConnectivityImpl::encode(eckit::Stream& s) const {
792 s << values_;
793 s << rows_;
794 s << cols_;
795 s << missing_value_;
796 }
797
798 void BlockConnectivityImpl::decode(eckit::Stream& s) {
799 owns_ = true;
800 s >> values_;
801 s >> rows_;
802 s >> cols_;
803 s >> missing_value_;
804 }
805
806 //------------------------------------------------------------------------------------------------------
807
808 size_t BlockConnectivityImpl::footprint() const {
809 size_t size = sizeof(*this);
810 if (owns()) {
811 size += values_.footprint();
812 }
813 return size;
814 }
815
816 //------------------------------------------------------------------------------------------------------
817
818 class ConnectivityPrivateAccess {
819 private:
820 using ctxt_t = Connectivity::ctxt_t;
821 using callback_t = Connectivity::callback_t;
822
823 public:
824 ConnectivityPrivateAccess(Connectivity& connectivity): connectivity_(connectivity) {}
825 ctxt_t& ctxt() { return connectivity_.ctxt_; }
826 callback_t& callback_update() { return connectivity_.callback_update_; }
827 callback_t& callback_delete() { return connectivity_.callback_delete_; }
828
829 idx_t* values() { return connectivity_.values_.data(); }
830 idx_t* displs() { return connectivity_.displs_.data(); }
831 idx_t* counts() { return connectivity_.counts_.data(); }
832
833 const char* name() { return connectivity_.name_; }
834
835 private:
836 Connectivity& connectivity_;
837 };
838
839 //------------------------------------------------------------------------------------------------------
840
841 extern "C" {
842 Connectivity* atlas__Connectivity__create() {
843 Connectivity* connectivity = nullptr;
844 connectivity = new Connectivity();
845 return connectivity;
846 }
847 void atlas__Connectivity__delete(Connectivity* This) {
848 delete This;
849 }
850
851 void atlas__connectivity__register_ctxt(Connectivity* This, Connectivity::ctxt_t ctxt) {
852 ConnectivityPrivateAccess access(*This);
853 access.ctxt() = ctxt;
854 }
855
856 int atlas__connectivity__ctxt(Connectivity* This, Connectivity::ctxt_t* ctxt) {
857 ConnectivityPrivateAccess access(*This);
858 *ctxt = access.ctxt();
859 return bool(access.ctxt());
860 }
861
862 void atlas__connectivity__register_update(Connectivity* This, Connectivity::callback_t callback) {
863 ConnectivityPrivateAccess access(*This);
864 access.callback_update() = callback;
865 }
866
867 void atlas__connectivity__register_delete(Connectivity* This, Connectivity::callback_t callback) {
868 ConnectivityPrivateAccess access(*This);
869 access.callback_delete() = callback;
870 }
871
872 void atlas__Connectivity__displs(Connectivity* This, idx_t*& displs, idx_t& size) {
873 ConnectivityPrivateAccess access(*This);
874 displs = access.displs();
875 size = This->rows() + 1;
876 }
877
878 void atlas__Connectivity__counts(Connectivity* This, idx_t*& counts, idx_t& size) {
879 ConnectivityPrivateAccess access(*This);
880 counts = access.counts();
881 size = This->rows();
882 }
883
884 void atlas__Connectivity__values(Connectivity* This, idx_t*& values, idx_t& size) {
885 ConnectivityPrivateAccess access(*This);
886 values = access.values();
887 size = This->rows() ? access.displs()[This->rows()] + 1 : 0;
888 }
889
890 void atlas__Connectivity__add_values(Connectivity* This, idx_t rows, idx_t cols, idx_t values[]) {
891 This->add(rows, cols, values, true);
892 }
893
894 void atlas__Connectivity__add_missing(Connectivity* This, idx_t rows, idx_t cols) {
895 This->add(rows, cols);
896 }
897
898 idx_t atlas__Connectivity__rows(const Connectivity* This) {
899 return This->rows();
900 }
901
902 idx_t atlas__Connectivity__missing_value(const Connectivity* This) {
903 return This->missing_value() TO_FORTRAN;
904 }
905
906 MultiBlockConnectivity* atlas__MultiBlockConnectivity__create() {
907 MultiBlockConnectivity* connectivity = nullptr;
908 connectivity = new MultiBlockConnectivity();
909 return connectivity;
910 }
911
912 idx_t atlas__MultiBlockConnectivity__blocks(const MultiBlockConnectivity* This) {
913 return This->blocks();
914 }
915
916 BlockConnectivityImpl* atlas__MultiBlockConnectivity__block(MultiBlockConnectivity* This, idx_t block_idx) {
917 ATLAS_ASSERT(This != nullptr);
918 BlockConnectivityImpl* block = &This->block(block_idx);
919 ATLAS_ASSERT(block != nullptr);
920 return block;
921 }
922
923 void atlas__BlockConnectivity__delete(BlockConnectivityImpl* This) {
924 delete This;
925 }
926
927 idx_t atlas__BlockConnectivity__rows(const BlockConnectivityImpl* This) {
928 ATLAS_ASSERT(This != nullptr);
929 return This->rows();
930 }
931
932 idx_t atlas__BlockConnectivity__cols(const BlockConnectivityImpl* This) {
933 ATLAS_ASSERT(This != nullptr);
934 return This->cols();
935 }
936
937 idx_t atlas__BlockConnectivity__missing_value(const BlockConnectivityImpl* This) {
938 ATLAS_ASSERT(This != nullptr);
939 return This->missing_value();
940 }
941
942 void atlas__BlockConnectivity__data(BlockConnectivityImpl* This, idx_t*& data, idx_t& rows, idx_t& cols) {
943 ATLAS_ASSERT(This != nullptr);
944 data = This->data();
945 rows = This->rows();
946 cols = This->cols();
947 }
948
949 const char* atlas__Connectivity__name(Connectivity* This) {
950 ATLAS_ASSERT(This);
951 return ConnectivityPrivateAccess(*This).name();
952 }
953
954 void atlas__Connectivity__rename(Connectivity* This, const char* name) {
955 ATLAS_ASSERT(This);
956 This->rename(std::string(name));
957 }
958 }
959
960 } // namespace mesh
961 } // namespace atlas