Branch data Line data Source code
1 : : #ifndef AMR_tet_store_h
2 : : #define AMR_tet_store_h
3 : :
4 : : #include <unordered_set>
5 : : #include <vector>
6 : :
7 : : #include "AMR_types.hpp"
8 : : #include "active_element_store.hpp"
9 : : #include "master_element_store.hpp"
10 : : #include "marked_refinements_store.hpp"
11 : : #include "edge_store.hpp"
12 : : #include "util.hpp"
13 : : #include "id_generator.hpp"
14 : :
15 : : namespace AMR {
16 : :
17 : : class tet_store_t {
18 : : public:
19 : : // FIXME: Remove this (center_tets) data structure!
20 : : // This is a horrendous code abuse, and I'm sorry. I'm fairly
21 : : // certain we'll be re-writing how this detection is done and just
22 : : // wanted a quick-fix so I could move on :(
23 : : std::set<size_t> center_tets; // Store for 1:4 centers
24 : :
25 : : std::set<size_t> delete_list; // For marking deletions in deref
26 : :
27 : : AMR::active_element_store_t active_elements;
28 : : AMR::master_element_store_t master_elements;
29 : :
30 : : std::vector< std::size_t > active_tetinpoel;
31 : : std::set< std::size_t > active_nodes;
32 : :
33 : : AMR::id_generator_t id_generator;
34 : :
35 : : std::unordered_set<size_t> intermediate_list;
36 : : // Public so it can be trivially grabbed for looping over.
37 : : std::vector< std::size_t > active_id_mapping;
38 : :
39 : : tet_list_t tets;
40 : : AMR::edge_store_t edge_store;
41 : :
42 : : // TODO: Make this (and others) private at some point
43 : : AMR::marked_refinements_store_t<AMR::Refinement_Case> marked_refinements;
44 : : AMR::marked_refinements_store_t<AMR::Derefinement_Case> marked_derefinements;
45 : :
46 : : /**
47 : : * @brief function to return the number of tets stored
48 : : *
49 : : * @return Num of tets
50 : : */
51 : 48 : size_t size() {
52 : 48 : return tets.size();
53 : : }
54 : :
55 : : /**
56 : : * @brief Helper to check if an given tet is active
57 : : *
58 : : * @param id id of the tool to check
59 : : *
60 : : * @return active status of tet
61 : : */
62 : 1397517 : bool is_active(size_t id)
63 : : {
64 : 1397517 : return active_elements.exists(id);
65 : : }
66 : :
67 : : /**
68 : : * @brief Return refinement case for a given id
69 : : *
70 : : * @param id id to get case for
71 : : *
72 : : * @return Refinement case for id
73 : : */
74 : 193934 : Refinement_Case get_refinement_case(size_t id)
75 : : {
76 : 193934 : return data(id).refinement_case;
77 : : }
78 : :
79 : : /**
80 : : * @brief Set value of normal
81 : : *
82 : : * @param id Id to set
83 : : * @param val true/false to set
84 : : */
85 : 137844 : void set_normal(size_t id, bool val)
86 : : {
87 : 137844 : data(id).normal = val;
88 : 137844 : }
89 : :
90 : : /**
91 : : * @brief Get normal value for given id
92 : : *
93 : : * @param id Id of tet to check
94 : : *
95 : : * @return true/false of normal value
96 : : */
97 : 51555 : bool is_normal(size_t id)
98 : : {
99 : : // should the underlying type be bool?
100 : 51555 : return data(id).normal;
101 : : }
102 : :
103 : : /**
104 : : * @brief set a tet as normal
105 : : *
106 : : * @param id id to set
107 : : */
108 : 0 : void mark_normal(size_t id)
109 : : {
110 : 0 : set_normal(id, true);
111 : 0 : }
112 : :
113 : : /**
114 : : * @brief get data for a tet from master element
115 : : *
116 : : * @param id id of tet to get
117 : : *
118 : : * @return state of the tet
119 : : */
120 : 593156 : Refinement_State& data(size_t id)
121 : : {
122 : 593156 : return master_elements.get(id);
123 : : }
124 : :
125 : 145458 : const Refinement_State& data(size_t id) const
126 : : {
127 : 145458 : return master_elements.get(id);
128 : : }
129 : :
130 : : /**
131 : : * @brief Method to insert tet into the tet store, so the
132 : : * underlying data structure doesn't have to be interfaced with
133 : : * directly
134 : : *
135 : : * @param id Id of the added tet
136 : : * @param t The tet element
137 : : */
138 : 1037478 : void insert(size_t id, tet_t t)
139 : : {
140 : : // cppcheck-suppress assertWithSideEffect
141 [ - + ]: 1037478 : assert( !exists(id) );
142 [ + - ]: 1037478 : tets.insert( std::pair<size_t, tet_t>(id, t));
143 : 1037478 : }
144 : :
145 : : /**
146 : : * @brief Getter for tet element
147 : : *
148 : : * @param id Id of tet to get
149 : : *
150 : : * @return Copy of the tet
151 : : */
152 : 2189070 : tet_t get( size_t id )
153 : : {
154 : : // cppcheck-suppress assertWithSideEffect
155 [ - + ]: 2189070 : assert( exists(id) );
156 : 2189070 : return tets.at(id);
157 : : }
158 : :
159 : : /**
160 : : * @brief Function to check if a tet exists. Useful for debugging
161 : : * access to invalid tets, or trying to re-create a tet which
162 : : * already exists
163 : : *
164 : : * @param id Id of the tet to check
165 : : *
166 : : * @return Bool stating if the tet already exists
167 : : */
168 : 3226548 : bool exists(size_t id)
169 : : {
170 [ + - ]: 3226548 : auto f = tets.find(id);
171 [ + + ]: 3226548 : if (f != tets.end())
172 : : {
173 : : //trace_out << "tet " << id << " exists." << std::endl;
174 : 2189070 : return true;
175 : : }
176 : 1037478 : return false;
177 : : }
178 : :
179 : : /**
180 : : * @brief Function to store a tet from a list of nodes
181 : : *
182 : : * @param id The ID of the tetrahedron to insert
183 : : * @param nodes The node ids which make up the tet
184 : : */
185 : 1037478 : void store_tet(size_t id, tet_t nodes) {
186 : :
187 : 1037478 : insert(id, nodes);
188 : :
189 : : // Sanity check the storage ids
190 : : // (this is probably better in a function/2d loop)
191 [ - + ]: 1037478 : assert( nodes[0] != nodes[1] );
192 [ - + ]: 1037478 : assert( nodes[0] != nodes[2] );
193 [ - + ]: 1037478 : assert( nodes[0] != nodes[3] );
194 [ - + ]: 1037478 : assert( nodes[1] != nodes[2] );
195 [ - + ]: 1037478 : assert( nodes[1] != nodes[3] );
196 [ - + ]: 1037478 : assert( nodes[2] != nodes[3] );
197 : 1037478 : }
198 : :
199 : : /**
200 : : * @brief Convenience function to store a tet without first building
201 : : * a list
202 : : *
203 : : * @param id The ID of the tetrahedron to store
204 : : * @param first First Node
205 : : * @param second Second Node
206 : : * @param third Third Node
207 : : * @param forth Forth Node
208 : : */
209 : : void store_tet(
210 : : size_t id,
211 : : size_t first,
212 : : size_t second,
213 : : size_t third,
214 : : size_t forth
215 : : )
216 : : {
217 : : store_tet( id, { {first, second, third, forth} } );
218 : : }
219 : :
220 : 112028 : void add(
221 : : size_t id,
222 : : const tet_t& nodes,
223 : : Refinement_Case refinement_case,
224 : : size_t parent_id
225 : : )
226 : : {
227 : :
228 : : //std::cout << "id " << id << " parent " << parent_id << std::endl;
229 : :
230 : 112028 : add_to_master(id, nodes, refinement_case, parent_id, true);
231 : :
232 : 224056 : master_elements.get(id).refinement_level =
233 : 112028 : master_elements.get(parent_id).refinement_level+1;
234 : :
235 : : // Deal with updating parent
236 : 112028 : master_elements.add_child(parent_id, id);
237 : :
238 : 112028 : trace_out << "Added child " << id << std::endl;
239 : 112028 : }
240 : :
241 : : /**
242 : : * @brief Convenience function to add a tet to the master_elements
243 : : * and active_elements store
244 : : *
245 : : * @param id The ID of the tetrahedron to add
246 : : * @param nodes A list of the nodes which form th etet
247 : : * @param refinement_case The refinement case which caused this tet
248 : : * to be generated
249 : : * @param parent_id The ID of the parent tetrahedron
250 : : * @param has_parent True if element has a parent
251 : : */
252 : 1037478 : void add_to_master(size_t id, const tet_t& nodes,
253 : : Refinement_Case refinement_case, size_t parent_id=0,
254 : : bool has_parent=false)
255 : : {
256 : 1037478 : store_tet(id, nodes);
257 : :
258 : 1037478 : size_t refinement_level = 0;
259 : :
260 : : // Add to master list
261 : 1037478 : master_elements.add(id, refinement_case, refinement_level, parent_id, has_parent);
262 : :
263 : : // The new master element should start as active
264 : 1037478 : active_elements.add(id);
265 : 1037478 : }
266 : :
267 : : /**
268 : : * @brief Interface to add a tet from the original mesh (no parent)
269 : : */
270 : 925450 : void add(const tet_t& nodes, Refinement_Case refinement_case)
271 : : {
272 : 925450 : size_t id = id_generator.get_next_tet_id();
273 : 925450 : add_to_master(id, nodes, refinement_case);
274 : 925450 : }
275 : :
276 : : // NOTE: this does *not* deal with edges
277 : : /**
278 : : * @brief Function to delete a tet from the tet store (useful in
279 : : * derefinement)
280 : : *
281 : : * @param id id of the tet to delete
282 : : */
283 : 48756 : void erase(size_t id)
284 : : {
285 : 48756 : deactivate(id);
286 : 48756 : master_elements.erase(id);
287 : 48756 : tets.erase(id);
288 : : // TODO: Should this update the number of children here rather than at the call site?
289 : 48756 : }
290 : :
291 : : /**
292 : : * @brief Function to remove a tet from the active tet list
293 : : *
294 : : * @param id The id of the tet to deactivate
295 : : */
296 : 62945 : void deactivate(size_t id) {
297 : 62945 : active_elements.erase(id);
298 : : // TODO: For safety, should we also mark it's edges as not
299 : : // needing to be refined?
300 : 62945 : }
301 : :
302 : 6280 : void activate(size_t id) {
303 [ + - ]: 6280 : if (!is_active(id) )
304 : : {
305 : 6280 : active_elements.add(id);
306 : : }
307 : 6280 : }
308 : :
309 : : /**
310 : : * @brief Function to add a tet to a list which maintains what is a
311 : : * center tet. (The need to maintain a list could be replaced by a
312 : : * geometric check on the tet itself)
313 : : *
314 : : * @param id Id of the tet to add
315 : : */
316 : 176 : void add_center(size_t id)
317 : : {
318 : : // cppcheck-suppress assertWithSideEffect
319 [ - + ]: 176 : assert( !is_center(id) );
320 : 176 : center_tets.insert(id);
321 : 176 : }
322 : :
323 : : /**
324 : : * @brief function to check if a tet is a center tet in a 1:4
325 : : *
326 : : * @param id Id of the tet to check
327 : : *
328 : : * @return Bool stating if it's a center tet or not
329 : : */
330 : 176 : bool is_center(size_t id)
331 : : {
332 [ + - ][ - + ]: 176 : if (center_tets.find(id) != center_tets.end())
333 : : {
334 : 0 : return true;
335 : : }
336 : 176 : return false;
337 : : }
338 : :
339 : : /**
340 : : * @brief Function to get a list of refinement levels, useful for
341 : : * vis
342 : : *
343 : : * @return Vector containing refinement levels of tets
344 : : */
345 : 98 : std::vector< real_t > get_refinement_level_list() const
346 : : {
347 : 98 : std::vector<real_t> refinement_level_list;
348 : :
349 [ + + ]: 150504 : for (const auto& kv : tets)
350 : : {
351 : 150406 : size_t element_id = kv.first;
352 [ + - ][ + + ]: 150406 : if (active_elements.exists( element_id )) {
353 : 133115 : real_t val = static_cast< tk::real >(
354 [ + - ]: 133115 : master_elements.get(element_id).refinement_level );
355 [ + - ]: 133115 : refinement_level_list.push_back(val);
356 : : }
357 : : }
358 : :
359 : 98 : trace_out << "Made refinement level list of len " << refinement_level_list.size() << std::endl;
360 : 98 : return refinement_level_list;
361 : 0 : }
362 : :
363 : : /**
364 : : * @brief Function to return a list of cell types, useful when
365 : : * invoking the vis to do coloring by cell type
366 : : *
367 : : * @return Vector listening the types of cells
368 : : */
369 : 98 : std::vector< real_t > get_cell_type_list() const
370 : : {
371 : 98 : std::vector<real_t> cell_type_list;
372 : :
373 [ + + ]: 150504 : for (const auto& kv : tets)
374 : : {
375 : 150406 : size_t element_id = kv.first;
376 : :
377 [ + - ][ + + ]: 150406 : if (active_elements.exists( element_id )) {
378 : :
379 : 133115 : real_t val = 0.0;
380 : :
381 : : // Be a good citizen, make this enum human readable
382 [ + - ][ + + ]: 133115 : switch (master_elements.get(element_id).refinement_case)
[ + + ][ - - ]
[ - - ]
383 : : {
384 : 260 : case Refinement_Case::one_to_two:
385 : 260 : val = 2.0;
386 : 260 : break;
387 : 704 : case Refinement_Case::one_to_four:
388 : 704 : val = 4.0;
389 : 704 : break;
390 : 125934 : case Refinement_Case::one_to_eight:
391 : 125934 : val = 8.0;
392 : 125934 : break;
393 : 6217 : case Refinement_Case::initial_grid:
394 : 6217 : val = 1.0;
395 : 6217 : break;
396 : : // TODO: this will never actually happen, as a 2:8 currently views
397 : : // itself as a 1:8 (as it did a 2:1, and a 1:8)
398 : 0 : case Refinement_Case::two_to_eight:
399 : 0 : val = 2.8;
400 : 0 : break;
401 : 0 : case Refinement_Case::four_to_eight:
402 : 0 : val = 4.8;
403 : 0 : break;
404 : 0 : case Refinement_Case::none:
405 : 0 : val = 0.0;
406 : 0 : break;
407 : : }
408 [ + - ]: 133115 : cell_type_list.push_back(val);
409 : : }
410 : : }
411 : :
412 : 98 : trace_out << "Made cell type list of len " << cell_type_list.size() << std::endl;
413 : 98 : return cell_type_list;
414 : 0 : }
415 : :
416 : : /**
417 : : * @brief The function gives a way to go back from active_inpoel to
418 : : * real AMR id
419 : : *
420 : : * @return A vector which hold the AMR ids of the active inpoel
421 : : */
422 : : std::vector< std::size_t >& get_active_id_mapping()
423 : : {
424 : : active_id_mapping.clear();
425 : :
426 : : for (const auto& kv : tets)
427 : : {
428 : : size_t element_id = kv.first;
429 : :
430 : : if (is_active( element_id )) {
431 : : active_id_mapping.push_back( element_id );
432 : : }
433 : : }
434 : :
435 : : return active_id_mapping;
436 : : }
437 : :
438 : : /**
439 : : * @brief Function to extract only the active elements from tetinpeol
440 : : *
441 : : * @return List of only active elements
442 : : */
443 : : // TODO: need equiv for m_x/m_y/m_z? Otherwise there will be
444 : : // useless nodes in m_x etc? (Although that's functionally fine)
445 : 366 : std::vector< std::size_t >& get_active_inpoel()
446 : : {
447 : 366 : active_tetinpoel.clear();
448 : 366 : active_nodes.clear();
449 : :
450 [ + + ]: 566371 : for (const auto& kv : tets)
451 : : {
452 : :
453 : 566005 : size_t element_id = kv.first;
454 : 566005 : auto t = kv.second;
455 : :
456 [ + - ][ + + ]: 566005 : if (is_active( element_id )) {
457 [ + - ]: 499432 : active_tetinpoel.push_back( t[0] );
458 [ + - ]: 499432 : active_tetinpoel.push_back( t[1] );
459 [ + - ]: 499432 : active_tetinpoel.push_back( t[2] );
460 [ + - ]: 499432 : active_tetinpoel.push_back( t[3] );
461 : :
462 [ + - ]: 499432 : active_nodes.insert( t[0] );
463 [ + - ]: 499432 : active_nodes.insert( t[1] );
464 [ + - ]: 499432 : active_nodes.insert( t[2] );
465 [ + - ]: 499432 : active_nodes.insert( t[3] );
466 : : }
467 : : }
468 : :
469 : 366 : return active_tetinpoel;
470 : : }
471 : :
472 : : // TODO: These mark methods can probably be a single one to which a
473 : : // Refinement_Case is passed, depending on how extra edges are marked
474 : : /**
475 : : * @brief Function to mark a given tet as needing a 1:2 refinement
476 : : *
477 : : * @param tet_id The tet to mark
478 : : */
479 : 529 : void mark_one_to_two(size_t tet_id)
480 : : {
481 : : // TODO: If none of these methods need extra markings, then
482 : : // change them into a single method
483 : 529 : trace_out << "Mark " << tet_id << " as 1:2" << std::endl;
484 : 529 : marked_refinements.add(tet_id, Refinement_Case::one_to_two);
485 : 529 : }
486 : :
487 : : /**
488 : : * @brief Mark a given tet as needing a 1:4 refinement
489 : : *
490 : : * @param tet_id The tet to mark
491 : : */
492 : 605 : void mark_one_to_four(size_t tet_id)
493 : : {
494 : 605 : trace_out << "Mark " << tet_id << " as 1:4" << std::endl;
495 : 605 : marked_refinements.add(tet_id, Refinement_Case::one_to_four);
496 : 605 : }
497 : :
498 : : /**
499 : : * @brief Mark a given tet as needing a 2:8 refinement
500 : : *
501 : : * @param tet_id id of tet to mark
502 : : */
503 : 0 : void mark_two_to_eight(size_t tet_id)
504 : : {
505 : 0 : trace_out << "Mark " << tet_id << " as 2:8" << std::endl;
506 : 0 : marked_refinements.add(tet_id, Refinement_Case::two_to_eight);
507 : 0 : }
508 : :
509 : : /**
510 : : * @brief Mark a given tet as needing a 4:8 refinement
511 : : *
512 : : * @param tet_id id of tet to mark
513 : : */
514 : 0 : void mark_four_to_eight(size_t tet_id)
515 : : {
516 : 0 : trace_out << "Mark " << tet_id << " as 4:8" << std::endl;
517 : 0 : marked_refinements.add(tet_id, Refinement_Case::four_to_eight);
518 : 0 : }
519 : :
520 : : /**
521 : : * @brief Function to mark a given tet as needing a 1:8 refinement
522 : : *
523 : : * @param tet_id The tet to mark
524 : : */
525 : 49500 : void mark_one_to_eight(size_t tet_id)
526 : : {
527 : 49500 : trace_out << "Mark " << tet_id << " as 1:8" << std::endl;
528 : 49500 : marked_refinements.add(tet_id, Refinement_Case::one_to_eight);
529 : 49500 : }
530 : :
531 : 137844 : bool has_refinement_decision(size_t id)
532 : : {
533 : 137844 : return marked_refinements.exists(id);
534 : : }
535 : :
536 : : /**
537 : : * @brief Helper debug function to print tet information
538 : : */
539 : 47 : void print_tets() {
540 [ + + ]: 137891 : for (const auto& kv : tets)
541 : : {
542 : 137844 : tet_t tet = kv.second;
543 : :
544 : 137844 : trace_out << "Tet " << kv.first << " has edges :" <<
545 : : tet[0] << ", " <<
546 : : tet[1] << ", " <<
547 : : tet[2] << ", " <<
548 : : tet[3] << ", " <<
549 : : std::endl;
550 : : }
551 : 47 : }
552 : :
553 : : void print_edges()
554 : : {
555 : : edge_store.print();
556 : : }
557 : :
558 : 71 : void print_node_types()
559 : : {
560 : :
561 : 71 : int initial_grid = 0;
562 : 71 : int one_to_two = 0;
563 : 71 : int one_to_four = 0;
564 : 71 : int one_to_eight = 0;
565 : 71 : int other = 0;
566 : :
567 [ + + ]: 145529 : for (const auto& kv : tets)
568 : : {
569 : 145458 : size_t tet_id = kv.first;
570 [ + - ][ + + ]: 145458 : if (is_active(tet_id))
571 : : {
572 [ + - ][ + + ]: 128167 : switch(get_refinement_case(tet_id))
[ + + ][ - - ]
[ - - ]
573 : : {
574 : 260 : case Refinement_Case::one_to_two:
575 : 260 : one_to_two++;
576 : 260 : break;
577 : 704 : case Refinement_Case::one_to_four:
578 : 704 : one_to_four++;
579 : 704 : break;
580 : 125934 : case Refinement_Case::one_to_eight:
581 : 125934 : one_to_eight++;
582 : 125934 : break;
583 : 1269 : case Refinement_Case::initial_grid:
584 : 1269 : initial_grid++;
585 : 1269 : break;
586 : 0 : case Refinement_Case::two_to_eight:
587 : : // Don't care (yet)
588 : 0 : other++;
589 : 0 : break;
590 : 0 : case Refinement_Case::four_to_eight:
591 : : // Don't care (yet)
592 : 0 : other++;
593 : 0 : break;
594 : 0 : case Refinement_Case::none:
595 : : // Don't care (yet)
596 : 0 : other++;
597 : 0 : break;
598 : : }
599 : :
600 : : }
601 : : }
602 : :
603 : : //std::cout << "Active Totals:" << std::endl;
604 : : //std::cout << " --> Initial = " << initial_grid << std::endl;
605 : : //std::cout << " --> 1:2 = " << one_to_two << std::endl;
606 : : //std::cout << " --> 1:4 = " << one_to_four << std::endl;
607 : : //std::cout << " --> 1:8 = " << one_to_eight << std::endl;
608 : 71 : }
609 : :
610 : 1925974 : edge_list_t generate_edge_keys(size_t tet_id)
611 : : {
612 [ + - ]: 1925974 : tet_t tet = get(tet_id);
613 [ + - ]: 3851948 : return edge_store.generate_keys(tet);
614 : : }
615 : :
616 : 925580 : void generate_edges(size_t i) {
617 : : // For tet ABCD, edges are:
618 : : // AB, AC, AD, BC, BD, CD
619 : : //
620 [ + - ]: 925580 : edge_list_t edge_list = generate_edge_keys(i);
621 : :
622 [ + + ]: 6479060 : for (size_t j = 0; j < NUM_TET_EDGES; j++)
623 : : {
624 : 5553480 : edge_t edge = edge_list[j];
625 : :
626 : 5553480 : size_t A = edge.first();
627 : 5553480 : size_t B = edge.second();
628 : :
629 : : Edge_Refinement er = Edge_Refinement(A, B, false,
630 : 5553480 : false, Edge_Lock_Case::unlocked);
631 : :
632 [ + - ]: 5553480 : edge_store.add(edge, er);
633 : : }
634 : 925580 : }
635 : :
636 : : /**
637 : : * @brief function to take a tet_id, finds it's nodes, and
638 : : * expresses them as faces
639 : : *
640 : : * Take tet ABCD, generate faces {ABC, ABD, ACD, BCD}
641 : : *
642 : : * @param tet_id The tet to generate faces for
643 : : *
644 : : * @return A list of faces making this tet
645 : : */
646 : 862 : face_list_t generate_face_lists(size_t tet_id)
647 : : {
648 : : // Hard code this for now...
649 [ + - ]: 862 : tet_t tet = get(tet_id);
650 : :
651 : 862 : trace_out << "Tet has nodes " <<
652 : : tet[0] << ", " <<
653 : : tet[1] << ", " <<
654 : : tet[2] << ", " <<
655 : : tet[3] << ", " <<
656 : : std::endl;
657 : :
658 : : face_list_t face_list;
659 : :
660 : : // ABC
661 : 862 : face_list[0][0] = tet[0];
662 : 862 : face_list[0][1] = tet[1];
663 : 862 : face_list[0][2] = tet[2];
664 : :
665 : : // ABD
666 : 862 : face_list[1][0] = tet[0];
667 : 862 : face_list[1][1] = tet[3];
668 : 862 : face_list[1][2] = tet[1];
669 : :
670 : : // ACD
671 : 862 : face_list[2][0] = tet[0];
672 : 862 : face_list[2][1] = tet[2];
673 : 862 : face_list[2][2] = tet[3];
674 : :
675 : : // BCD
676 : 862 : face_list[3][0] = tet[1];
677 : 862 : face_list[3][1] = tet[3];
678 : 862 : face_list[3][2] = tet[2];
679 : :
680 : 1724 : return face_list;
681 : : }
682 : :
683 : : /**
684 : : * @brief Function which marks all edges in a given tet as needing
685 : : * to be refined
686 : : *
687 : : * @param tet_id ID of the tet to mark
688 : : */
689 : 49500 : void mark_edges_for_refinement(size_t tet_id)
690 : : {
691 [ + - ]: 49500 : edge_list_t edge_list = generate_edge_keys(tet_id);
692 [ + + ]: 346500 : for (size_t k = 0; k < NUM_TET_EDGES; k++)
693 : : {
694 : 297000 : edge_t edge = edge_list[k];
695 [ + - ]: 297000 : edge_store.mark_for_refinement(edge);
696 : 297000 : trace_out << "Marking edge " << edge << " for refine " << std::endl;
697 : : }
698 : 49500 : }
699 : :
700 : : /**
701 : : * @brief Delete existing edges. Iterate over the tets, and add them to
702 : : * the edge store.
703 : : */
704 : : // FIXME: Better name for this?
705 : 2468 : void generate_edges() {
706 : :
707 : : // Go over tets, and generate all known edges
708 : 2468 : edge_store.edges.clear();
709 : :
710 : : // Jump over tets
711 [ + + ]: 927918 : for (const auto& kv : tets)
712 : : {
713 : 925450 : size_t tet_id = kv.first;
714 [ + - ]: 925450 : generate_edges(tet_id);
715 : : }
716 : 2468 : }
717 : :
718 : 0 : void unset_marked_children(size_t parent_id)
719 : : {
720 : 0 : Refinement_State& parent = data(parent_id);
721 [ - - ]: 0 : for (auto c : parent.children)
722 : : {
723 [ - - ]: 0 : marked_refinements.erase(c);
724 : : }
725 : 0 : }
726 : :
727 : 14189 : child_id_list_t generate_child_ids(size_t parent_id, size_t count = MAX_CHILDREN)
728 : : {
729 : 14189 : return id_generator.generate_child_ids(parent_id, count);
730 : : }
731 : 136844 : size_t get_child_id(size_t parent_id, size_t offset) const
732 : : {
733 : 136844 : return master_elements.get_child_id(parent_id, offset);
734 : : }
735 : :
736 : 0 : size_t get_parent_id(size_t id) const
737 : : {
738 : 0 : return master_elements.get_parent(id);
739 : : }
740 : :
741 : : // Deref
742 : 24 : void process_delete_list()
743 : : {
744 : 24 : trace_out << "process_delete_list " << delete_list.size() << std::endl;
745 : 24 : size_t original_size = size();
746 [ - + ]: 24 : for(auto f : delete_list) {
747 [ - - ]: 0 : erase(f);
748 : : }
749 : :
750 : 24 : size_t end_size = size();
751 : 24 : trace_out << "Deleted " << original_size-end_size << std::endl;
752 : :
753 : 24 : delete_list.clear();
754 : 24 : }
755 : : /**
756 : : * @brief Function to mark a given tet as a specific Derefinement_Case
757 : : *
758 : : * @param tet_id The tet to mark
759 : : * @param decision The Derefinement_case to set
760 : : */
761 : 14957 : void mark_derefinement_decision(size_t tet_id, AMR::Derefinement_Case decision)
762 : : {
763 : 14957 : trace_out << "MARKING_DEREF_DECISION" << std::endl;
764 : 14957 : marked_derefinements.add(tet_id, decision);
765 : 14957 : }
766 : 7614 : bool has_derefinement_decision(size_t id)
767 : : {
768 : 7614 : return marked_derefinements.exists(id);
769 : : }
770 : :
771 : : };
772 : : }
773 : :
774 : : #endif // guard
|
