InteriorBoundary.h 3.84 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

/** \file InteriorBoundary.h */

#ifndef AMDIS_INTERIORBOUNDARY_H
#define AMDIS_INTERIORBOUNDARY_H

#include <vector>
Thomas Witkowski's avatar
Thomas Witkowski committed
27
#include <map>
28

29
#include "AMDiS_fwd.h"
30
#include "BoundaryObject.h"
31
#include "parallel/MeshLevelData.h"
32 33 34

namespace AMDiS {

35 36
  using namespace std;

37 38 39 40 41
  /** \brief
   * Defines the interior boundary, i.e. a bound within the domain. It is used for
   * the classical domain decomposition parallelization.
   */
  class InteriorBoundary {
Thomas Witkowski's avatar
Thomas Witkowski committed
42
  public:
43
    typedef map<int, vector<AtomicBoundary> > RankToBoundMap;
Thomas Witkowski's avatar
Thomas Witkowski committed
44

Thomas Witkowski's avatar
Thomas Witkowski committed
45 46 47 48
    /// Iterator for the interior boundary object.
    class iterator {      
    public:
      iterator(InteriorBoundary &b)
49 50 51 52 53 54
	: bound(b),
	  level(0)
      {
	reset();
      }

55
      iterator(InteriorBoundary &b, int level)
56 57
	: bound(b),
	  level(level)
Thomas Witkowski's avatar
Thomas Witkowski committed
58
      {
59 60 61
	TEST_EXIT_DBG(level < bound.boundary.size())
	  ("Should not happen!\n");

Thomas Witkowski's avatar
Thomas Witkowski committed
62 63 64 65 66 67
	reset();
      }

      /// Set the iterator to the first position.
      void reset()
      {
68
	mapIt = bound.boundary[level].begin();
Thomas Witkowski's avatar
Thomas Witkowski committed
69 70
	nextNonempty();

71
	if (mapIt != bound.boundary[level].end())
Thomas Witkowski's avatar
Thomas Witkowski committed
72 73 74 75 76 77
	  vecIt = mapIt->second.begin();	
      }

      /// Test if iterator is at the final position.
      bool end() const
      {
78
	return (mapIt == bound.boundary[level].end());
Thomas Witkowski's avatar
Thomas Witkowski committed
79 80 81 82 83 84 85 86 87 88
      }

      /// Move iterator to the next position.
      void operator++()
      {
	++vecIt;
	if (vecIt == mapIt->second.end()) {
	  ++mapIt;
	  nextNonempty();

89
	  if (mapIt != bound.boundary[level].end())
Thomas Witkowski's avatar
Thomas Witkowski committed
90 91 92 93
	    vecIt = mapIt->second.begin();	  
	}	
      }

94 95 96 97 98 99 100 101 102 103
      inline AtomicBoundary& operator*()
      {
	return *vecIt;
      }

      inline AtomicBoundary* operator->()
      {
	return &(*vecIt);
      }

Thomas Witkowski's avatar
Thomas Witkowski committed
104 105 106 107 108
      void nextRank()
      {
	++mapIt;
	nextNonempty();

109
	if (mapIt != bound.boundary[level].end())
Thomas Witkowski's avatar
Thomas Witkowski committed
110 111 112
	  vecIt = mapIt->second.begin();	
      }

113
      inline int getRank() 
Thomas Witkowski's avatar
Thomas Witkowski committed
114 115 116 117 118 119 120 121
      {
	return mapIt->first;
      }

    protected:

      inline void nextNonempty()
      {
122
	if (mapIt == bound.boundary[level].end())
Thomas Witkowski's avatar
Thomas Witkowski committed
123 124
	  return;

125 126 127 128
	while (mapIt->second.size() == 0) {
	  ++mapIt;
	  if (mapIt == bound.boundary[level].end())
	    return;	  
Thomas Witkowski's avatar
Thomas Witkowski committed
129 130 131 132 133 134
	}
      }

    protected:
      RankToBoundMap::iterator mapIt;

135
      vector<AtomicBoundary>::iterator vecIt;
Thomas Witkowski's avatar
Thomas Witkowski committed
136 137

      InteriorBoundary &bound;
138 139

      int level;
Thomas Witkowski's avatar
Thomas Witkowski committed
140 141
    };

142
  public:
143 144
    InteriorBoundary(int l = 1) 
      : nLevel(l)
Thomas Witkowski's avatar
Thomas Witkowski committed
145
    {
146
      boundary.resize(nLevel);
Thomas Witkowski's avatar
Thomas Witkowski committed
147 148
    }

149 150 151
    void reset(int nLevel);

    AtomicBoundary& getNewAtomic(int level, int rank);
Thomas Witkowski's avatar
Thomas Witkowski committed
152

153
    /// Writes this object to a file.
154
    void serialize(ostream &out);
155

156
    /// Reads the state of an interior boundary from a file.
157
    void deserialize(istream &in, map<int, Element*> &elIndexMap);
158

159 160 161 162
    /// Compares this interior boundaries with some other. The order of the
    /// boundary elements within the object does not play a role.
    bool operator==(const InteriorBoundary& other) const;

163
  protected:
164
    void serializeExcludeList(ostream &out, ExcludeList &list);
165

166
    void deserializeExcludeList(istream &in, ExcludeList &list);    
167

Thomas Witkowski's avatar
Thomas Witkowski committed
168
  public:
169 170 171 172
    vector<RankToBoundMap> boundary;    

  protected:
    int nLevel;
173 174 175 176
  };
}

#endif // AMDIS_INTERIORBOUNDARY_H