RCNeighbourList.h 6.71 KB
Newer Older
1
2
3
4
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
5
// ==  http://www.amdis-fem.org                                              ==
6
7
// ==                                                                        ==
// ============================================================================
8
9
10
11
12
13
14
15
16
17
18
19
//
// Software License for AMDiS
//
// Copyright (c) 2010 Dresden University of Technology 
// All rights reserved.
// Authors: Simon Vey, Thomas Witkowski et al.
//
// This file is part of AMDiS
//
// See also license.opensource.txt in the distribution.


20
21
22
23
24
25
26
27

/** \file RCNeighbourList.h */

#ifndef AMDIS_RCNEIGHBOURLIST_H
#define AMDIS_RCNEIGHBOURLIST_H

#include <vector>
#include <deque>
Thomas Witkowski's avatar
Thomas Witkowski committed
28
#include "AMDiS_fwd.h"
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include "Global.h"

namespace AMDiS {

  /** \ingroup Adaption 
   * \brief
   * Stores information about coarsening and refinement patches. For refining 
   * and coarsening we need information of the elements at the refinement and 
   * coarsening edge. Thus, we have to collect all elements at this edge. In 2d 
   * we have at most the current element and its neighbour across this edge, if
   * the edge is not part of the boundary. In 3d we have to loop around this 
   * edge to collect all the elements. Every element at the edge has at most two
   * neighbours sharing the same edge. Defining an orientation for this edge, 
   * we can define the right and left neighbour.
   * For every element at the refinement/coarsening edge we have an entry in a 
   * vector. The elements of this vector build the refinement/coarsening patch.
   * In 2d the vector has length 2 and in 3d length mesh->getMaxEdgeNeigh() 
   * since this is the maximal number of elements sharing the same edge in the 
   * Mesh.
   */
  class RCNeighbourList
  {
  public:
52
    /// Constructs a RCNeighbourList of size maxEdgeNeigh
53
54
    RCNeighbourList(int maxEdgeNeigh);

55
    RCNeighbourList() {}
56

57
    /// Destructor
58
59
    virtual ~RCNeighbourList();

60
    /// Sets flag of \ref rclist[i] = true
Thomas Witkowski's avatar
Thomas Witkowski committed
61
62
    inline void setCoarsePatch(int i) 
    {
63
64
      rclist[i]->flag = true;
    }
65

66
    /// Sets flag of \ref rclist[i] = f
Thomas Witkowski's avatar
Thomas Witkowski committed
67
68
    inline void setCoarsePatch(int i, bool f) 
    {
69
70
      rclist[i]->flag = f;
    }
71

72
    /// Returns \ref rclist[i].flag
Thomas Witkowski's avatar
Thomas Witkowski committed
73
74
    inline const bool isPatchCoarse(int i) const 
    {
75
76
      return rclist[i]->flag;
    }
77
78
79

    /** \brief
     * If \ref rclist[i].neigh[j] is not a NULL pointer 
80
     * \ref rclist[i].neigh[j]->ith will be returned. Otherwise the return value is -1
81
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
82
83
    inline int getNeighbourNr(int i, int j) const 
    {
84
      return rclist[i]->neigh[j] ? rclist[i]->neigh[j]->ith : -1;
85
    }
86
87
88
89
90
91

    /** \brief
     * If \ref rclist[i].neigh[j] is not a NULL pointer 
     * \ref rclist[i].neigh[j]->el will be returned. Otherwise the return value
     * is NULL
     */
Thomas Witkowski's avatar
Thomas Witkowski committed
92
93
    inline Element* getNeighbourElement(int i, int j) const 
    {
94
      return rclist[i]->neigh[j] ? rclist[i]->neigh[j]->el : NULL; 
95
    }
96

97
    /// Returns \ref rclist[i].el
Thomas Witkowski's avatar
Thomas Witkowski committed
98
99
    inline Element* getElement(int i) const 
    {
100
101
      if (static_cast<int>(rclist.size()) <= i) 
	return NULL;
102

103
      return rclist[i]->el;
104
    }
105

106
    /// Sets \ref rclist[i].el to el and \ref rclist[i].flag to cp.
Thomas Witkowski's avatar
Thomas Witkowski committed
107
108
    inline const Element* setElement(int i, const Element* el, bool cp = false) 
    {
109
110
      rclist[i]->el = const_cast<Element*>(el);
      rclist[i]->flag = cp;
111

112
      return el;
113
    }
114

115
    /// Returns \ref rclist[i].elType
Thomas Witkowski's avatar
Thomas Witkowski committed
116
117
    inline int getType(int i) const 
    {
118
119
      return rclist[i]->elType;
    }
120

Thomas Witkowski's avatar
Thomas Witkowski committed
121
122
    inline void setType(int i, int type) const 
    {
123
      rclist[i]->elType = type; 
124
    }
125

126
    /// If patch can be coarsend return true, else false and reset the element marks.
127
128
    virtual bool doCoarsePatch(int n_neigh);

129
    /// Sets \ref rclist[i].oppVertex[j] = k
130
    inline void setOppVertex(int i, int j, int k) 
Thomas Witkowski's avatar
Thomas Witkowski committed
131
    {
132
133
      rclist[i]->oppVertex[j] = k;
    }
134
  
135
    /// Returns \ref rclist[i].oppVertex[j]
Thomas Witkowski's avatar
Thomas Witkowski committed
136
137
    inline int getOppVertex(int i, int j) 
    { 
138
139
      return rclist[i]->oppVertex[j]; 
    }
140

141
    /// Sets \ref rclist[i].elType = t
142
    inline void setElType(int i, unsigned char t) 
Thomas Witkowski's avatar
Thomas Witkowski committed
143
    {
144
145
      rclist[i]->elType = t;
    }
146

147
    /// Sets \ref coarseningManager = cm
Thomas Witkowski's avatar
Thomas Witkowski committed
148
149
    inline void setCoarseningManager(CoarseningManager *cm) 
    { 
150
      coarseningManager = cm; 
151
    }
152
153

    /** \brief
154
     * Fills \ref rclist[i].neigh and \ref rclist[i].oppVertex  infos (0 <= i 
155
156
     * < n_neigh)
     */
157
    void fillNeighbourRelations(int n_neigh, int bound);
158
159
160
161
162
163
164
165
166
167
168
169
170

    /** \brief
     * Adds those dof's on the parent that are handed on by the
     * children and adds the dof in the midpoint of the coarsening edge (3d) 
     */
    void addDOFParent(int elIndex, DegreeOfFreedom* dof);

    /** \brief
     * If DOFs for higher order are been removed on parents during refinement
     * they are now added again (2d)
     */
    void addDOFParents(int n_neigh);

171
    /// Removes DOFs during refinement (3d)
172
173
    void removeDOFParent(int index);

174
    /// Removes DOFs during refinement (2d)
175
176
    void removeDOFParents(int n_neigh);  

177
178
179
180
181
182
183
    void periodicSplit(DegreeOfFreedom *edge[2],
		       DegreeOfFreedom *nextEdge[2],
		       int *n_neigh,
		       int *n_neigh_periodic,
		       RCNeighbourList &periodicList);

    void clearList();
184
185

  protected:
186
    /// Information about one Element of the patch
187
188
189
    class RCListElement
    {
    public:
190
      /// Pointer to the Element
191
192
      Element* el;

193
194
      /// This is the i-th entry in the RCNeighbourList 
      int ith;
195
196
197
198
199
200
201
202
203
204
205
206
207
208

      /** \brief
       * Only used in the coarsening module: flag is true if the coarsening 
       * edge of the Element is the coarsening edge of the patch, otherwise 
       * flag is false;
       */
      bool flag;

      /** \brief
       * neigh[0/1] neighbour of element to the right/left in the orientation 
       * of the edge, or a NULL pointer in the case of a boundary face (only 3d)
       */
      RCListElement* neigh[2];

209
      /// opp vertex[0/1] the opposite vertex of neigh[0/1] (only 3d)
210
211
212
213
214
215
216
217
218
219
220
221
      int oppVertex[2];

      /** \brief
       * The element type; is set during looping around the 
       * refinement/coarsening edge; if neighbour information is produced by the
       * traversal routines, information about the type of an element can not be
       * accessed via el->getType() and thus has to be stored in the 
       * RCListElement vector (only 3d)
       */
      unsigned char elType;
    };

222
    /// Refinement/coarsening patch
223
    std::vector<RCListElement*> rclist;
224

225
    /// Pointer to the CoarseningManager
226
227
228
229
230
231
    CoarseningManager *coarseningManager; 
  };

}

#endif  // AMDIS_RCNEIGHBOURLIST_H