RCNeighbourList.h 6.64 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 
Thomas Witkowski's avatar
Thomas Witkowski committed
80
     * \ref rclist[i].neigh[j]->no 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]->no:-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
      return rclist[i]->el;
103
    }
104

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

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

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

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

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

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

145
    /// Sets \ref coarseningManager = cm
Thomas Witkowski's avatar
Thomas Witkowski committed
146
147
    inline void setCoarseningManager(CoarseningManager *cm) 
    { 
148
      coarseningManager = cm; 
149
    }
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

    /** \brief
     * Fills \ref rclist[i].neigh and \ref rclist[i].oppVertex  infos ( 0 <= i 
     * < n_neigh)
     */
    void getNeighOnPatch(int n_neigh, int bound);

    /** \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);

169
    /// Removes DOFs during refinement (3d)
170
171
    void removeDOFParent(int index);

172
    /// Removes DOFs during refinement (2d)
173
174
175
176
177
178
179
180
    void removeDOFParents(int n_neigh);  

    RCNeighbourList *periodicSplit(DegreeOfFreedom *edge[2],
				   DegreeOfFreedom *nextEdge[2],
				   int *n_neigh,
				   int *n_neigh_periodic);

  protected:
181
    /// Information about one Element of the patch
182
183
184
    class RCListElement
    {
    public:
185
      /// Pointer to the Element
186
187
      Element* el;

188
      /// This is the no-th entry in the RCNeighbourList 
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
      int no;

      /** \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];

204
      /// opp vertex[0/1] the opposite vertex of neigh[0/1] (only 3d)
205
206
207
208
209
210
211
212
213
214
215
216
      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;
    };

217
    /// Refinement/coarsening patch
218
    std::vector<RCListElement*> rclist;
219

220
    /// Pointer to the CoarseningManager
221
222
223
224
225
226
    CoarseningManager *coarseningManager; 
  };

}

#endif  // AMDIS_RCNEIGHBOURLIST_H