DofComm.h 4.27 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 27 28 29 30 31 32 33 34 35 36
// ============================================================================
// ==                                                                        ==
// == 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>
#include "FiniteElemSpace.h"
#include "Global.h"

namespace AMDiS {

  using namespace std;

  class DofComm
  {
  public:
37 38 39
    DofComm() 
      : data(1)
    {}
40 41 42
    
    typedef map<const FiniteElemSpace*, DofContainer> FeMapType;
    typedef FeMapType::iterator FeMapIter;
43
    typedef map<int, FeMapType> DataType;
44
    typedef DataType::iterator DataIter;
45 46
    // meshLevel: map[rank -> map[feSpace -> DofContainer]]
    typedef vector<DataType> LevelDataType;
47

48 49 50
    inline DofContainer& getDofContainer(int rank, 
					 const FiniteElemSpace *feSpace, 
					 int level = 0)
51
    {
52
      return data[level][rank][feSpace];
53 54 55 56
    }

    void removeEmpty();

57
    void init(int nLevels = 1)
58 59
    {
      data.clear();
60
      data.resize(nLevels);
61 62
    }

63
    DataType& getData(int level = 0)
64
    {
65
      return data[level];
66 67
    }

68 69
    int getNumberDofs(int level, const FiniteElemSpace *feSpace);

70
  protected:
71
    LevelDataType data;
72 73 74 75 76 77 78 79 80 81 82

    friend class Iterator;

  public:
    class Iterator
    {
    public:
      Iterator(DofComm &dc,
	       const FiniteElemSpace *fe = NULL)
	: dofComm(dc),
	  dofCounter(-1),
83 84
	  traverseFeSpace(fe),
	  traverseLevel(0)
85
      {
86 87
	goFirst();
      }
88

89 90 91 92 93 94 95 96 97
      Iterator(DofComm &dc,
	       int level,
	       const FiniteElemSpace *fe = NULL)
	: dofComm(dc),
	  dofCounter(-1),
	  traverseFeSpace(fe),
	  traverseLevel(level)
      {
	goFirst();
98 99 100 101
      }

      inline bool end()
      {
102
	return (dataIter == dofComm.data[traverseLevel].end());
103 104 105 106
      }
      
      inline void nextRank()
      {
107 108 109
	do {
	  ++dataIter;
	} while (setNextFeMap() == false);
110 111 112 113 114 115 116
      }

      inline void nextFeSpace()
      {
	++feMapIter;
      }

117 118 119 120
      inline void next()
      {
	++feMapIter;
	if (feMapIter == dataIter->second.end()) {
121 122 123
	  do {
	    ++dataIter;
	  } while (setNextFeMap() == false);
124 125 126 127 128 129
	} else {
	  dofIter = feMapIter->second.begin();
	  dofCounter = 0;
	}
      }

130 131 132 133 134 135 136 137 138 139 140 141
      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;
	}

142 143 144 145
	if (feMapIter != dataIter->second.end()) {
	  dofIter = feMapIter->second.begin();
	  dofCounter = 0;
	}
146 147 148 149
      }

      inline bool endDofIter()
      {
150 151 152
	if (feMapIter == dataIter->second.end())
	  return true;

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
	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:
193 194 195 196 197 198 199 200
      void goFirst()
      {
	dataIter = dofComm.data[traverseLevel].begin();

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

201
      bool setNextFeMap();
202 203 204 205 206 207 208 209 210 211 212 213 214

    protected:
      DofComm &dofComm;
      
      DofComm::DataIter dataIter;
      
      DofComm::FeMapIter feMapIter;

      DofContainer::iterator dofIter;

      int dofCounter;

      const FiniteElemSpace *traverseFeSpace;
215 216

      int traverseLevel;
217 218 219 220 221 222 223 224
    };


  };

}

#endif // AMDIS_DOF_COMM_H