Branch data     Line data    Source code

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