SmrNode.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_SmrNode_h__)
#define __geom_mesh_simplicial_SmrNode_h__

#if defined(DEBUG_geom) && !defined(DEBUG_SmrNode)
#define DEBUG_SmrNode
#endif

#ifdef DEBUG_SmrNode
#ifndef DEBUG_Node_VertSelfId
// Debug the base class.
#define DEBUG_Node_VertSelfId
#endif
#endif

#include "Node_VertSelfId.h"

#include "../../../ads/iterator/IndirectIterator.h"

#include <vector>

BEGIN_NAMESPACE_GEOM


template<class SMR>
class SmrNode {
  //
  // Enumerations.
  //

public:

  enum {N = SMR::N};

  //
  // Public types.
  //

public:

  typedef SMR Mesh;

  typedef typename Mesh::CellIterator CellIterator;
  typedef typename Mesh::CellConstIterator CellConstIterator;

  typedef typename Mesh::NodeIterator NodeIterator;
  typedef typename Mesh::NodeConstIterator NodeConstIterator;

  typedef typename Mesh::Number Number;
  typedef ads::FixedArray<N,Number> Vertex;

  //
  // Private types.
  //

private:

  typedef std::vector<CellIterator> CellIteratorContainer;

  //
  // More public types.
  //

public:

  typedef typename CellIteratorContainer::iterator CellIteratorIterator;
  typedef typename CellIteratorContainer::const_iterator 
  CellIteratorConstIterator;

  typedef ads::IndirectIterator<typename CellIteratorContainer::iterator> 
  CellIncidentToNodeIterator;
  typedef ads::IndirectIterator<typename 
  CellIteratorContainer::const_iterator> 
  CellIncidentToNodeConstIterator;

  //
  // Data
  //
      
private:
      
  Vertex _vertex;
  NodeIterator _self;
  mutable int _identifier;
  CellIteratorContainer _cells;

public:

  //--------------------------------------------------------------------------

  SmrNode() :
    _vertex(),
    _self( 0 ),
    _identifier(-1),
    _cells()
  {}

  SmrNode(const Vertex& vertex, const int identifier = -1) :
    _vertex(vertex),
    _self(0),
    _identifier(identifier),
    _cells()
  {}

  void
  build(const Vertex& vertex, const int identifier = -1,
        const NodeIterator self = 0) {
    _vertex = vertex;
    _self = self;
    _identifier = identifier;
    _cells.clear();
  }

  SmrNode(const SmrNode& other) :
    _vertex(other._vertex),
    _self(other._self),
    _identifier(other._identifier),
    _cells(other._cells)
  {}

  ~SmrNode()
  {}

  //--------------------------------------------------------------------------
      
  SmrNode& 
  operator=(const SmrNode& other) {
    if (&other != this) {
      _vertex = other._vertex;
      _self = other._self;
      _identifier = other._identifier;
      _cells = other._cells;
    }
    return *this;
  }

  //--------------------------------------------------------------------------

  const Vertex&
  getVertex() const { 
    return _vertex;
  }


  int
  getIdentifier() const {
    return _identifier;
  }

  NodeConstIterator
  getSelf() const { 
    return _self;
  }

  CellConstIterator
  getCell() const {
    // If there are no incident cells.
    if (_cells.empty()) {
      // Return a null iterator.
      return CellConstIterator(0);
    }
    // Return the first adjacent cell in the container.
    return _cells.front();
  }

  int
  getCellsSize() const {
    return int(_cells.size());
  }

  CellIncidentToNodeConstIterator
  getCellsBeginning() const {
    return CellIncidentToNodeConstIterator(_cells.begin());
  }

  CellIncidentToNodeConstIterator
  getCellsEnd() const {
    return CellIncidentToNodeConstIterator(_cells.end());
  }

  CellIteratorConstIterator
  getCellIteratorsBeginning() const {
    return _cells.begin();
  }

  CellIteratorConstIterator
  getCellIteratorsEnd() const {
    return _cells.end();
  }

  bool
  hasCell(const CellConstIterator cellIterator) const {
    for (CellIteratorConstIterator i = _cells.begin(); i != _cells.end(); 
         ++i) {
      if (*i == cellIterator) {
        return true;
      }
    }
    return false;
  }


  bool
  isOnBoundary() const {
    // For each simplex incident to this vertex.
    for (CellIteratorConstIterator cii = _cells.begin();
         cii != _cells.end(); ++cii) {
      // If this cell has a face incident to this vertex and on the boundary.
      if ((*cii)->hasIncidentBoundaryFace(getSelf())) {
        // This vertex is on the boundary.
        return true;
      }
    }
    // We did not encounter any incident boundary faces.
    return false;
  }


  //--------------------------------------------------------------------------

  void
  setVertex(const Vertex& vertex) { 
    _vertex = vertex;
  }


  void
  setIdentifier(const int identifier) const { 
    _identifier = identifier;
  }

  NodeIterator
  getSelf() { 
    return _self;
  }

  void
  setSelf(const NodeIterator self) { 
    _self = self;
  }

  CellIterator
  getCell() { 
    // If there are no incident cells.
    if (_cells.empty()) {
      // Return a null iterator.
      return CellIterator(0);
    }
    // Return the first adjacent cell in the container.
    return _cells.front();
  }

  void
  insertCell(const CellIterator c) {
    // The cell iterator should not be null.
    assert(c != 0);
#ifdef DEBUG_SmrNode
    // The cell should not already be in the container of incident cells.
    // This test is a little expensive, so it is only checked in debugging 
    // mode.
    assert(! hasCell(c));
#endif    
    _cells.push_back(c);
  }

  template<typename CellIterInIter>
  void
  insertCells(CellIterInIter begin, CellIterInIter end) {
    for (; begin != end; ++begin) {
      insertCell(*begin);
    }
  }

  void
  removeCell(const CellIterator c) {
    // Find the cell.
    CellIteratorIterator i;
    i = std::find(_cells.begin(), _cells.end(), c);
    // The specified cell must be incident to this vertex.
    assert(i != _cells.end());
    // Remove the incident cell.
    _cells.erase(i);
  }

  CellIncidentToNodeIterator
  getCellsBeginning() {
    return CellIncidentToNodeIterator(_cells.begin());
  }

  CellIncidentToNodeIterator
  getCellsEnd() {
    return CellIncidentToNodeIterator(_cells.end());
  }

  CellIteratorIterator
  getCellIteratorsBeginning() {
    return _cells.begin();
  }

  CellIteratorIterator
  getCellIteratorsEnd() {
    return _cells.end();
  }


  void
  replace(NodeIterator node) {
    // Vertex Index.
    int vertexIndex;
    // Loop over the incident cells.
    CellIncidentToNodeIterator i = getCellsBeginning();
    CellIncidentToNodeIterator iEnd = getCellsEnd();
    for (; i != iEnd; ++i) {
      // The index of this node.
      vertexIndex = i->getIndex(getSelf());
      // Replace this node with the specified one.
      i->setNode(vertexIndex, node);
    }
  }

  //--------------------------------------------------------------------------
  
  bool
  operator==(const SmrNode& x) const {
    return _self == x._self && _vertex == x._vertex && 
      _identifier == x._identifier && _cells == x._cells;
  }

  bool
  operator!=(const SmrNode& x) const {
    return ! operator==(x);
  }

  //--------------------------------------------------------------------------

  void
  put(std::ostream& out) const {
    // Write the point and the vertex identifier.
    out << "Vertex = " << _vertex << " Id = " << getIdentifier();
    // Write the incident cell identifiers.
    const int iEnd = int(_cells.size());
    // CONTINUE REMOVE
    out << " cells = ";
    for (int i = 0; i != iEnd; ++i) {
      out << " " << _cells[i]->getIdentifier();
    }
    out << "\n";
  }

};

END_NAMESPACE_GEOM

#endif

---