InteriorBoundary.h

// ============================================================================
// ==                                                                        ==
// == 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 InteriorBoundary.h */

#ifndef AMDIS_INTERIORBOUNDARY_H
#define AMDIS_INTERIORBOUNDARY_H

#include <vector>
#include <map>

#include "AMDiS_fwd.h"
#include "MacroElement.h"
#include "Element.h"
#include "Boundary.h"
#include "parallel/MeshLevelData.h"

namespace AMDiS {

  using namespace std;

  typedef vector<pair<GeoIndex, int> > ExcludeList;

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

    BoundaryObject();

    BoundaryObject(Element *e, 
		   int eType, 
		   GeoIndex sObj, 
		   int iObj, 
		   bool rMode = false);

    static bool computeReverseMode(BoundaryObject &obj0,
				   BoundaryObject &obj1,
				   const FiniteElemSpace *feSpace,
				   BoundaryType boundary);

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

    /// The macro element to which the boundary element corresponds to.
    Element* el;

    /// Index of the macro element.
    int elIndex;

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

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

    /** \brief
     * Defines which of vertex, edge or face of the macro element is part of the
     * boundary.
     *
     * 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
     * boundary.
     */
    int ithObj;

    bool reverseMode;

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



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

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

    /// The rank's part of the boundary.
    BoundaryObject rankObj;

    /// The object on the other side of the boundary.
    BoundaryObject neighObj;

    /// 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;
  };



  /** \brief
   * Defines the interior boundary, i.e. a bound within the domain. It is used for
   * the classical domain decomposition parallelization.
   */
  class InteriorBoundary {
  public:
    typedef map<int, vector<AtomicBoundary> > RankToBoundMap;

    /// Iterator for the interior boundary object.
    class iterator {      
    public:
      iterator(InteriorBoundary &b)
	: bound(b),
	  levelData(NULL),
	  level(0)
      {
	reset();
      }

      iterator(InteriorBoundary &b, MeshLevelData &levelData, int level)
	: bound(b),
	  levelData(&levelData),
	  level(level)
      {
	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();	  
	}	
      }

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

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

      void nextRank()
      {
	++mapIt;
	nextNonempty();

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

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

    protected:

      inline void nextNonempty()
      {
	if (mapIt == bound.boundary.end())
	  return;

	if (level > 0) {
	  TEST_EXIT_DBG(levelData)("No mesh level data object defined!\n");
	  TEST_EXIT_DBG(level == 1)("Only 2-level method supported!\n");

	  while (levelData->rankInSubdomain(mapIt->first, level) ||
		 mapIt->second.size() == 0) {
	    ++mapIt;
	    if (mapIt == bound.boundary.end())
	      return;	  
	  }
	} else {
	  while (mapIt->second.size() == 0) {
	    ++mapIt;
	    if (mapIt == bound.boundary.end())
	      return;
	  }
	}
      }

    protected:
      RankToBoundMap::iterator mapIt;

      vector<AtomicBoundary>::iterator vecIt;

      InteriorBoundary &bound;

      MeshLevelData *levelData;

      int level;
    };

  public:
    InteriorBoundary() {}

    void clear()
    {
      boundary.clear();
    }

    AtomicBoundary& getNewAtomic(int rank);

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

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

    /// 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;

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

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

  public:
    RankToBoundMap boundary;
  };
}

#endif // AMDIS_INTERIORBOUNDARY_H