1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165 | #ifndef AMR_master_element_store_h
#define AMR_master_element_store_h
#include <map><--- Include file:
#include <algorithm><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <cassert><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include "Refinement_State.hpp"
#include "AMR/Loggers.hpp" // for trace_out<--- Include file: "AMR/Loggers.hpp" not found.
namespace AMR {
class master_element_store_t {
private:
std::map<size_t, Refinement_State> master_elements;
public:
//! Non-const-ref access to state
std::map<size_t, Refinement_State>& data() {
return master_elements;
}
/**
* @brief Add an element to the master element list.
*
* @param element_number The element number to add (currently
* somewhat redundant?)
* @param refinement_case The refinement_case which gave rise to
* this element
* @param refinement_level The level of refinement
* @param parent_id The id of the parent element
* @param has_parent True if element has a parent, default is true
*
* @return The id of the added element
*/
// TODO: These add methods could probably be much tidier. The
// current none reliance on default input values is nice, as it
// means that we don't have to do any checks on if a valid value
// was passed for the base case..
size_t add(
size_t element_number,
Refinement_Case refinement_case,
size_t refinement_level,
size_t parent_id,
bool has_parent=true
)
{
Refinement_State d = Refinement_State(
element_number,
refinement_case,
refinement_level,
parent_id,
has_parent
);
master_elements.insert( std::pair<size_t, Refinement_State>(element_number, d));
return element_number;
}
/**
* @brief Accessor method to retrieve master element by element id
*
* @param id The element_id of the master_element to fetch
*
* @return The master_element which represents the corresponding tet
*/
Refinement_State& get(size_t id)
{
// cppcheck-suppress assertWithSideEffect
assert( exists(id) );
return master_elements.at(id);
}
const Refinement_State& get(size_t id) const
{
assert( exists(id) );
return master_elements.at(id);
}
/**
* @brief Function to check if master element entry exists. Useful
* for debugging access to invalid elements, or trying to re-create
* an element which already exists
*
* @param id Id to check
*
* @return Bool stating if the element already exists
*/
bool exists(size_t id) const
{
auto f = master_elements.find(id);
if (f != master_elements.end())
{
//trace_out << "master_elements " << id << " exists." << std::endl;
return true;
}
return false;
}
/**
* @brief Getting function to access parent of a given ID
*
* @param id ID to find parent of
*
* @return ID of parent
*/
size_t get_parent(size_t id) const
{
return get(id).parent_id;
}
/**
* @brief Getting function to find child id for a given parent
*
* @param parent_id ID of parent
* @param offset Offset into child list (i.e child number)
*
* @return ID of the child
*/
size_t get_child_id(size_t parent_id, size_t offset) const
{
// cppcheck-suppress assertWithSideEffect
assert(offset < get(parent_id).children.size());
return get(parent_id).children[offset];
}
/**
* @brief Wrapper function to calculate number of master elements
*
* @return total number of master elements
*/
size_t size() {
return master_elements.size();
}
/**
* @brief Add child to a given node, to track the relationship and
* allow graph traversal
*
* @param parent_id ID of the parent
* @param child_id ID of the child
*/
void add_child(size_t parent_id, size_t child_id)
{
get(parent_id).children.push_back(child_id);
// cppcheck-suppress assertWithSideEffect
assert( get(parent_id).children.size() <= 8);
}
/**
* @brief Remove id from master_element (relevant for
* de-refinement)
*
* @param id ID of element to remove
*/
void erase(size_t id) {
master_elements.erase(id);
}
};
}
#endif // guard
|