Liebe Gitlab-Nutzer, lieber Gitlab-Nutzer,
es ist nun möglich sich mittels des ZIH-Logins/LDAP an unserem Dienst anzumelden. Die Konten der externen Nutzer:innen sind über den Reiter "Standard" erreichbar.
Die Administratoren


Dear Gitlab user,
it is now possible to log in to our service using the ZIH login/LDAP. The accounts of external users can be accessed via the "Standard" tab.
The administrators

InteriorBoundary.h 6.17 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 31
#include "MacroElement.h"
#include "Element.h"
32
#include "Boundary.h"
33 34 35

namespace AMDiS {

36 37
  typedef std::vector<std::pair<GeoIndex, int> > ExcludeList;

38 39
  /// Defines the geometrical objects that forms the boundary;
  struct BoundaryObject {
40

41 42 43
    BoundaryObject()      
      : elType(0),
	reverseMode(false),
44
	excludedSubstructures(0)
45 46
    {}

47
    BoundaryObject(Element *e, int eType, GeoIndex sObj, int iObj, bool rMode = false)
48 49 50 51 52
      : el(e),
	elIndex(e->getIndex()),
	elType(eType),
	subObj(sObj),
	ithObj(iObj),
53
	reverseMode(rMode),
54
	excludedSubstructures(0)
55
    {}
56

57 58 59 60 61 62
    void setReverseMode(BoundaryObject &otherBound, FiniteElemSpace *feSpace);

    bool operator==(const BoundaryObject& other) const;
    
    bool operator!=(const BoundaryObject& other) const;

63
    /// The macro element to which the boundary element corresponds to.
Thomas Witkowski's avatar
Thomas Witkowski committed
64
    Element* el;
65

66 67 68
    /// Index of the macro element.
    int elIndex;

69 70 71
    /// Element type index, only used in 3d.
    int elType;

72 73 74 75
    /** \brief
     * Defines the geometrical object at the boundary. It must be "a part" of the
     * macro element \ref el, i.e., either 1 (a vertex), 2 (an edge) or 3 (a face).
     */
76
    GeoIndex subObj;
77 78 79 80 81

    /** \brief
     * Defines which of vertix, edge or face of the macro element is part of the
     * boundary.
     *
82 83 84
     * Example: If the macro element is a triangle, than \ref subObj may be either
     * 1 (vertex) or 2 (edge). Assume its the last one. So this variable defines
     * which of the three possible edges of the triangle is at the interior
85 86
     * boundary.
     */
87
    int ithObj;
88 89 90

    bool reverseMode;

91 92 93 94 95 96 97 98 99
    /** \brief
     * In many situations it may be necessary to exclude some parts of the element to
     * be part of the boundary. In 3d, when a face is part of the boundary, an edge or
     * an vertex may be exludeded. In 2d only vertices may be exluded to be part of
     * an edge boundary. This list contains pairs of exludeded structures. The first
     * component of every pair denotes if it is a vertex or an edge, and the second
     * component denotes the local index of the structure.
     */
    ExcludeList excludedSubstructures;
100 101 102 103 104 105 106
  };

  /** \brief 
   * Defines one atomic part of the boundary, i.e., two boundary objects where the
   * boundary goes through.
   */
  struct AtomicBoundary {
107 108 109 110 111 112
    AtomicBoundary()
      : type(INTERIOR)
    {}

    bool operator==(const AtomicBoundary& other) const;

113
    /// The rank's part of the boundary.
114
    BoundaryObject rankObj;
115 116

    /// The object on the other side of the boundary.
117
    BoundaryObject neighObj;
118 119 120 121 122

    /// Integer flag that is used to distinguish between different types of 
    /// boundaries. Till now it is used only for periodic boundaries, which are also
    /// handles as interior boundaries.
    BoundaryType type;
123 124 125 126 127 128 129
  };

  /** \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
130 131 132
  public:
    typedef std::map<int, std::vector<AtomicBoundary> > RankToBoundMap;

Thomas Witkowski's avatar
Thomas Witkowski committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
    /// Iterator for the interior boundary object.
    class iterator {      
    public:
      iterator(InteriorBoundary &b)
	: bound(b)
      {
	reset();
      }

      /// Set the iterator to the first position.
      void reset()
      {
	mapIt = bound.boundary.begin();
	nextNonempty();

	if (mapIt != bound.boundary.end())
	  vecIt = mapIt->second.begin();	
      }

      /// Test if iterator is at the final position.
      bool end() const
      {
	return (mapIt == bound.boundary.end());
      }

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

	  if (mapIt != bound.boundary.end())
	    vecIt = mapIt->second.begin();	  
	}	
      }

171 172 173 174 175 176 177 178 179 180
      inline AtomicBoundary& operator*()
      {
	return *vecIt;
      }

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

Thomas Witkowski's avatar
Thomas Witkowski committed
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
      void nextRank()
      {
	++mapIt;
	nextNonempty();

	if (mapIt != bound.boundary.end())
	  vecIt = mapIt->second.begin();	
      }

      int getRank() 
      {
	return mapIt->first;
      }

    protected:

      inline void nextNonempty()
      {
Thomas Witkowski's avatar
Thomas Witkowski committed
199 200 201
	if (mapIt == bound.boundary.end())
	  return;

Thomas Witkowski's avatar
Thomas Witkowski committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
 	while (mapIt->second.size() == 0) {
 	  ++mapIt;
	  if (mapIt == bound.boundary.end())
	    return;
	}
      }

    protected:
      RankToBoundMap::iterator mapIt;

      std::vector<AtomicBoundary>::iterator vecIt;

      InteriorBoundary &bound;
    };

217
  public:
Thomas Witkowski's avatar
Thomas Witkowski committed
218 219
    InteriorBoundary() {}

Thomas Witkowski's avatar
Thomas Witkowski committed
220 221 222 223 224
    void clear()
    {
      boundary.clear();
    }

225
    AtomicBoundary& getNewAtomic(int rank);
Thomas Witkowski's avatar
Thomas Witkowski committed
226

227
    /// Writes this object to a file.
228 229
    void serialize(std::ostream &out);

230 231
    /// Reads the state of an interior boundary from a file.
    void deserialize(std::istream &in, std::map<int, Element*> &elIndexMap);
232

233 234 235 236
    /// 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;

237 238 239 240 241
  protected:
    void serializeExcludeList(std::ostream &out, ExcludeList &list);

    void deserializeExcludeList(std::istream &in, ExcludeList &list);

Thomas Witkowski's avatar
Thomas Witkowski committed
242
  public:
Thomas Witkowski's avatar
Thomas Witkowski committed
243
    RankToBoundMap boundary;
244 245 246 247
  };
}

#endif // AMDIS_INTERIORBOUNDARY_H