DofComm.h 5.67 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// ============================================================================
// ==                                                                        ==
// == AMDiS - Adaptive multidimensional simulations                          ==
// ==                                                                        ==
// ==  http://www.amdis-fem.org                                              ==
// ==                                                                        ==
// ============================================================================
//
// 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.



/** \file DofComm.h */

#ifndef AMDIS_DOF_COMM_H
#define AMDIS_DOF_COMM_H

#include <map>
27
#include "parallel/ParallelTypes.h"
28
29
30
31
32
33
34
35
36
37
#include "FiniteElemSpace.h"
#include "Global.h"

namespace AMDiS {

  using namespace std;

  class DofComm
  {
  public:
38
    DofComm() 
39
40
      : recvDofs(1),
	sendDofs(1),
41
42
43
44
	periodicDofs(0),
	meshLevel(-1),
	nLevel(0),
	levelData(NULL)
45
    {}
46
47
48
    
    typedef map<const FiniteElemSpace*, DofContainer> FeMapType;
    typedef FeMapType::iterator FeMapIter;
49
    typedef map<int, FeMapType> DataType;
50
    typedef DataType::iterator DataIter;
51
52
    // meshLevel: map[rank -> map[feSpace -> DofContainer]]
    typedef vector<DataType> LevelDataType;
53

54
55
56
    void init(int level, 
	      MeshLevelData &levelData, 
	      vector<const FiniteElemSpace*> &fe);
57
58
59
60
61
62
63
64
65
66
67

    void create(InteriorBoundary &boundary);

    LevelDataType& getSendDofs()
    {
      return sendDofs;
    }

    LevelDataType& getRecvDofs()
    {
      return recvDofs;
68
69
    }

70
    LevelDataType& getPeriodicDofs()
71
    {
72
      return periodicDofs;
73
74
    }

75
76
77
78
79
    // Writes all data of this object to an output stream.
    void serialize(ostream &out)
    {
      ERROR_EXIT("MUST BE IMPLEMENTED!\n");
    }
80

81
82
83
84
85
86
87
88
89
90
91
92
93
    // Reads the object data from an input stream.
    void deserialize(istream &in, 
		     map<const FiniteElemSpace*, map<int, const DegreeOfFreedom*> > dofIndexMap)
    {
      ERROR_EXIT("MUST BE IMPLEMENTED!\n");
    }

    int getNumberDofs(LevelDataType &data, 
		      int level, 
		      const FiniteElemSpace *feSpace);

  protected:
    void createContainer(RankToBoundMap &boundary, LevelDataType &data);
94

95
  protected:
96
97
98
99
100
101
102
103
104
105
106
107
108
109
    /// This map contains for each rank the list of DOFs the current rank must 
    /// end to exchange solution DOFs at the interior boundaries.
    LevelDataType sendDofs;

    /// This map contains on each rank the list of DOFs from which the current 
    /// rank will receive DOF values (i.e., this are all DOFs at an interior 
    /// boundary). The DOF indices are given in rank's local numbering.
    LevelDataType recvDofs;

    /// This map contains on each rank a list of DOFs along the interior bound-
    /// aries to communicate with other ranks. The DOF indices are given in rank's
    /// local numbering. Periodic boundaries within one subdomain are not 
    /// considered here. 
    LevelDataType periodicDofs;
110

111
112
    int meshLevel;

113
114
    int nLevel;

115
116
    MeshLevelData *levelData;

117
118
    vector<const FiniteElemSpace*> feSpaces;

119
120
121
122
123
124
    friend class Iterator;

  public:
    class Iterator
    {
    public:
125
      Iterator(LevelDataType &d,
126
	       const FiniteElemSpace *fe = NULL)
127
	: data(d),
128
	  dofCounter(-1),
129
130
	  traverseFeSpace(fe),
	  traverseLevel(0)
131
      {
132
133
	goFirst();
      }
134

135
      Iterator(LevelDataType &d,
136
137
	       int level,
	       const FiniteElemSpace *fe = NULL)
138
	: data(d),
139
140
141
142
143
	  dofCounter(-1),
	  traverseFeSpace(fe),
	  traverseLevel(level)
      {
	goFirst();
144
145
146
147
      }

      inline bool end()
      {
148
	return (dataIter == data[traverseLevel].end());
149
150
151
152
      }
      
      inline void nextRank()
      {
153
154
155
	do {
	  ++dataIter;
	} while (setNextFeMap() == false);
156
157
158
159
160
161
162
      }

      inline void nextFeSpace()
      {
	++feMapIter;
      }

163
164
165
166
      inline void next()
      {
	++feMapIter;
	if (feMapIter == dataIter->second.end()) {
167
168
169
	  do {
	    ++dataIter;
	  } while (setNextFeMap() == false);
170
171
172
173
174
175
	} else {
	  dofIter = feMapIter->second.begin();
	  dofCounter = 0;
	}
      }

176
177
178
179
180
181
182
183
184
185
186
187
      inline void beginDofIter(const FiniteElemSpace *fe = NULL)
      {
	FUNCNAME("DofComm::Iterator::beginDofIter()");

	if (fe != NULL) {
	  feMapIter = dataIter->second.begin();

	  while (feMapIter->first != fe &&
		 feMapIter != dataIter->second.end())
	    ++feMapIter;
	}

188
189
190
191
	if (feMapIter != dataIter->second.end()) {
	  dofIter = feMapIter->second.begin();
	  dofCounter = 0;
	}
192
193
194
195
      }

      inline bool endDofIter()
      {
196
197
198
	if (feMapIter == dataIter->second.end())
	  return true;

199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
	return (dofIter == feMapIter->second.end());
      }
      
      inline void nextDof()
      {
	++dofIter;
	++dofCounter;
      }

      inline int getRank()
      {
	return dataIter->first;
      }

      inline const FiniteElemSpace* getFeSpace()
      {
	return feMapIter->first;
      }

      inline DofContainer& getDofs()
      {
	return feMapIter->second;
      }

      inline const DegreeOfFreedom* getDof()
      {
	return *dofIter;
      }

      inline DegreeOfFreedom getDofIndex()
      {
	return **dofIter;
      }

      inline int getDofCounter()
      {
	return dofCounter;
      }

    protected:
239
240
      void goFirst()
      {
241
	dataIter = data[traverseLevel].begin();
242
243
244
245
246

	while (setNextFeMap() == false)
	  ++dataIter;
      }

247
      bool setNextFeMap();
248
249

    protected:
250
      LevelDataType &data;
251
252
253
254
255
256
257
258
259
260
      
      DofComm::DataIter dataIter;
      
      DofComm::FeMapIter feMapIter;

      DofContainer::iterator dofIter;

      int dofCounter;

      const FiniteElemSpace *traverseFeSpace;
261
262

      int traverseLevel;
263
264
265
266
267
268
269
270
    };


  };

}

#endif // AMDIS_DOF_COMM_H