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                 :          0 :               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                 :          0 :             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                 :          0 :                 );
      54                 :            : 
      55 [ -  - ][ -  - ]:          0 :                 master_elements.insert( std::pair<size_t, Refinement_State>(element_number, d));
      56                 :            : 
      57                 :          0 :                 return element_number;
      58                 :            :             }
      59                 :            : 
      60                 :            :             /**
      61                 :            :              * @brief Add a master element, with a specified parent_id which is
      62                 :            :              * used to udpate the refinement_level
      63                 :            :              *
      64                 :            :              * @param element_number The element number to add
      65                 :            :              * @param refinement_case The refinement_case which gave rise to
      66                 :            :              * this element
      67                 :            :              * @param parent_id The id of the parent element
      68                 :            :              *
      69                 :            :              * @return The id of the added element
      70                 :            :              */
      71                 :            :             size_t add(
      72                 :            :                  size_t element_number,
      73                 :            :                  Refinement_Case refinement_case,
      74                 :            :                  size_t parent_id
      75                 :            :             )
      76                 :            :             {
      77                 :            :                 size_t refinement_level =
      78                 :            :                     get(parent_id).refinement_level + 1;
      79                 :            : 
      80                 :            :                 trace_out << "Refinement Level " << refinement_level <<
      81                 :            :                     std::endl;
      82                 :            : 
      83                 :            :                 add(element_number, refinement_case,
      84                 :            :                         refinement_level, parent_id);
      85                 :            : 
      86                 :            :                 return element_number;
      87                 :            :             }
      88                 :            : 
      89                 :            :             /**
      90                 :            :              * @brief Accessor method to retrieve master element by element id
      91                 :            :              *
      92                 :            :              * @param id The element_id of the master_element to fetch
      93                 :            :              *
      94                 :            :              * @return The master_element which represents the corresponding tet
      95                 :            :              */
      96                 :            :             Refinement_State& get(size_t id)
      97                 :            :             {
      98                 :            :                 // cppcheck-suppress assertWithSideEffect
      99                 :            :                 assert( exists(id) );
     100 [ -  - ][ -  - ]:          0 :                 return master_elements.at(id);
         [ -  - ][ -  - ]
         [ -  - ][ -  - ]
         [ -  - ][ -  - ]
         [ -  - ][ -  - ]
     101                 :            :             }
     102                 :            : 
     103                 :            :             const Refinement_State& get(size_t id) const
     104                 :            :             {
     105                 :            :                 assert( exists(id) );
     106 [ -  - ][ -  - ]:          0 :                 return master_elements.at(id);
     107                 :            :             }
     108                 :            : 
     109                 :            :             /**
     110                 :            :              * @brief Function to check if master element entry exists. Useful
     111                 :            :              * for debugging access to invalid elements, or trying to re-create
     112                 :            :              * an element which already exists
     113                 :            :              *
     114                 :            :              * @param id Id to check
     115                 :            :              *
     116                 :            :              * @return Bool stating if the element already exists
     117                 :            :              */
     118                 :            :             bool exists(size_t id) const
     119                 :            :             {
     120                 :            :                 auto f = master_elements.find(id);
     121                 :            :                 if (f != master_elements.end())
     122                 :            :                 {
     123                 :            :                     //trace_out << "master_elements " << id << " exists." << std::endl;
     124                 :            :                     return true;
     125                 :            :                 }
     126                 :            :                 return false;
     127                 :            :             }
     128                 :            : 
     129                 :            :             /**
     130                 :            :              * @brief Getting function to access parent of a given ID
     131                 :            :              *
     132                 :            :              * @param id ID to find parent of
     133                 :            :              *
     134                 :            :              * @return ID of parent
     135                 :            :              */
     136                 :            :             size_t get_parent(size_t id) const
     137                 :            :             {
     138 [ -  - ][ -  - ]:          0 :                 return get(id).parent_id;
     139                 :            :             }
     140                 :            : 
     141                 :            :             /**
     142                 :            :              * @brief Getting function to find child id for a given parent
     143                 :            :              *
     144                 :            :              * @param parent_id ID of parent
     145                 :            :              * @param offset Offset into child list (i.e child number)
     146                 :            :              *
     147                 :            :              * @return ID of the child
     148                 :            :              */
     149                 :            :             size_t get_child_id(size_t parent_id, size_t offset) const
     150                 :            :             {
     151                 :            :                 // cppcheck-suppress assertWithSideEffect
     152                 :            :                 assert(offset < get(parent_id).children.size());
     153                 :            :                 return get(parent_id).children[offset];
     154                 :            :             }
     155                 :            : 
     156                 :            :             /**
     157                 :            :              * @brief Wrapper function to calculate number of master elements
     158                 :            :              *
     159                 :            :              * @return total number of master elements
     160                 :            :              */
     161                 :            :             size_t size() {
     162                 :            :                 return master_elements.size();
     163                 :            :             }
     164                 :            : 
     165                 :            :             /**
     166                 :            :              * @brief Add child to a given node, to track the relationship and
     167                 :            :              * allow graph traversal
     168                 :            :              *
     169                 :            :              * @param parent_id ID of the parent
     170                 :            :              * @param child_id ID of the child
     171                 :            :              */
     172                 :            :             void add_child(size_t parent_id, size_t child_id)
     173                 :            :             {
     174                 :          0 :                 get(parent_id).children.push_back(child_id);
     175                 :            : 
     176                 :            :                 // cppcheck-suppress assertWithSideEffect
     177                 :            :                 assert( get(parent_id).children.size() <= 8);
     178                 :            :             }
     179                 :            : 
     180                 :            :             /**
     181                 :            :              * @brief  Remove id from master_element (relevant for
     182                 :            :              * de-refinement)
     183                 :            :              *
     184                 :            :              * @param id ID of element to remove
     185                 :            :              */
     186                 :            :             void erase(size_t id) {
     187                 :            :                 master_elements.erase(id);
     188                 :            :             }
     189                 :            : 
     190                 :            : 
     191                 :            :     };
     192                 :            : }
     193                 :            : 
     194                 :            : #endif // guard