Line data Source code
1 : // This file is part of the Mamico project. For conditions of distribution
2 : // and use, please see the copyright notice in Mamico's main folder
3 : #pragma once
4 :
5 : #include "coupling/CouplingMDDefinitions.h"
6 : #include "coupling/datastructures/CouplingCell.h"
7 : #include "coupling/datastructures/FlexibleCellContainer.h"
8 : #include "coupling/indexing/IndexingService.h"
9 : #include <cstddef>
10 : #include <iostream>
11 : #include <iterator>
12 : #include <utility>
13 : #include <vector>
14 :
15 : namespace coupling {
16 : namespace datastructures {
17 : template <unsigned int dim> class FlexibleCellContainer;
18 : }
19 : } // namespace coupling
20 :
21 : /**
22 : * @brief provides access to coupling cells, which may belong to different indexing domains
23 : *
24 : * The FlexibleCellContainer is intended for use in cell domains which do not neatly correspond to a predefined indexing domain. For example, a CellContainer
25 : * cannot store cells in the macro2md overlap layers, and hence a FlexibleCellContainer is needed. Due to the "holes" expected due to the
26 : * non-contiguous nature of this container, index-based access is not possible or expected.
27 : * @tparam dim Number of dimensions; it can be 1, 2 or 3
28 : */
29 :
30 36 : template <unsigned int dim> class coupling::datastructures::FlexibleCellContainer {
31 : public:
32 8 : FlexibleCellContainer() {}
33 36 : FlexibleCellContainer(std::vector<coupling::datastructures::CouplingCell<dim>*> couplingCells, std::vector<I01> idxs) {
34 : #if (COUPLING_MD_DEBUG == COUPLING_MD_YES)
35 : if (couplingCells.size() != idxs.size()) {
36 : std::cout << "ERROR size of index vector and coupling cell vector sent to FlexibleCellContainer constructor do not match";
37 : exit(EXIT_FAILURE);
38 : }
39 : #endif
40 36 : _couplingCells.reserve(couplingCells.size());
41 36 : _idxs.reserve(idxs.size());
42 396 : for (std::size_t i = 0; i < couplingCells.size(); ++i) {
43 360 : _couplingCells.push_back(couplingCells[i]);
44 360 : _idxs.push_back(idxs[i]);
45 : }
46 36 : }
47 :
48 : template <class Container_T> FlexibleCellContainer(Container_T cells) {
49 : if constexpr (std::is_same_v<Container_T, FlexibleCellContainer>) {
50 : _idxs = cells._idxs;
51 : _couplingCells = cells._couplingCells;
52 : } else {
53 : auto numCells = cells.size();
54 : _idxs.reserve(numCells);
55 : _couplingCells.reserve(numCells);
56 : for (auto pair : cells)
57 : *this << pair;
58 : }
59 : }
60 :
61 : /** Adds a new coupling cell to the datastructure at the next index
62 : * @param cell a pointer to the cell to be inserted
63 : */
64 44 : void operator<<(std::pair<coupling::datastructures::CouplingCell<dim>*, I01> pair) {
65 44 : I01 idx;
66 : coupling::datastructures::CouplingCell<dim>* couplingCell;
67 44 : std::tie(couplingCell, idx) = pair;
68 44 : _couplingCells.push_back(couplingCell);
69 44 : _idxs.push_back(idx);
70 44 : }
71 :
72 : /**
73 : * Returns size of the underlying container.
74 : *
75 : * The number of indices stored should be equal to the number of cells stored, hence returning either is okay
76 : * @return the number of cells stored currently
77 : */
78 8 : unsigned int size() const { return _couplingCells.size(); }
79 :
80 : /**
81 : * @brief Provides iterator functionality (increment, access as <*cell, index> pair, equality)
82 : */
83 : class Iterator {
84 : public:
85 : using CouplingCellIterator = typename std::vector<coupling::datastructures::CouplingCell<dim>*>::const_iterator;
86 : using IndexIterator = std::vector<I01>::const_iterator;
87 :
88 140 : Iterator(CouplingCellIterator itCouplingCells, IndexIterator itIdxs) : _itCouplingCells(itCouplingCells), _itIdxs(itIdxs) {}
89 :
90 : /**
91 : * Iterator access, returning the data at the current iterator location
92 : *
93 : * @return a std::pair with the cell pointer and the index of the data that the iterator points to
94 : */
95 408 : const std::pair<coupling::datastructures::CouplingCell<dim>*, I01> operator*() const { return std::make_pair(*_itCouplingCells, *_itIdxs); }
96 :
97 320 : Iterator& operator++() {
98 120 : ++_itCouplingCells;
99 320 : ++_itIdxs;
100 120 : return *this;
101 : }
102 :
103 200 : Iterator operator++(int) {
104 200 : Iterator tmp = *this;
105 200 : ++(*this);
106 200 : return tmp;
107 : }
108 :
109 56 : friend bool operator==(const Iterator& a, const Iterator& b) { return a._itCouplingCells == b._itCouplingCells && a._itIdxs == b._itIdxs; }
110 :
111 232 : friend bool operator!=(const Iterator& a, const Iterator& b) { return !(a == b); }
112 :
113 : private:
114 : /**Iterator to underlying cell* vector */
115 : CouplingCellIterator _itCouplingCells;
116 :
117 : /**Iterator to underlying index vector */
118 : IndexIterator _itIdxs;
119 : };
120 : /** Provides pointer to beginning of iterator of this container */
121 44 : Iterator begin() const { return Iterator(_couplingCells.begin(), _idxs.begin()); }
122 :
123 : /** Provides pointer to end of iterator of this container */
124 96 : Iterator end() const { return Iterator(_couplingCells.end(), _idxs.end()); }
125 :
126 : private:
127 : /**Vector to store pointers to cells */
128 : std::vector<coupling::datastructures::CouplingCell<dim>*> _couplingCells;
129 :
130 : /**Vector to store indices corresponding to cells in container
131 : * Since the cells can be part of any domain, they're stores as I01 (global noghost) type.
132 : */
133 : std::vector<I01> _idxs;
134 : };
|
