geometry/continuityData.hh

Go to the documentation of this file.

/* data structures and some algorithms to find the supports for
   continuous shape functions on vertices (2D and 3D) and edges (3D)
*/

#ifndef continuityData_hh
#define continuityData_hh

#include <iostream>
#include <map>
#include "geometry/cell.hh"
#include "geometry/connector.hh"
#include "basics/exceptions.hh"
#include "toolbox/hashMap.hh"
#include "toolbox/set.hh"

namespace concepts {

  class CellData;

  // ******************************************************** WrongRelations **

  class WrongRelations : public ExceptionBase {};


  // ********************************************************* ConnectorData **

  class ConnectorData {
  public:
    typedef std::map<uint, const CellData*>::iterator iterator;
    typedef std::map<uint, const CellData*>::const_iterator const_iterator;

    void addCell(const CellData& c);
    bool hasCell(const Connector& c) const;
    void replaceCell(const CellData& remove, const CellData& add);

    iterator begin() { return cells_.begin(); }
    const_iterator begin() const { return cells_.begin(); }
    iterator end() { return cells_.end(); }
    const_iterator end() const { return cells_.end(); }
  protected:
    std::map<uint, const CellData*> cells_;
  };

  // ************************************************************** CellData **

  class CellData {
  public:
    CellData(const Connector& cell, const CellData* father) :
      cell_(cell) {
      addFather(father);
      cntrData_.addCell(*this);
    }
    const Connector& cell() const { return cell_; }
    const Connector1* edge(const uint i) const;
    const Connector2* face(const uint i) const;
    bool hasFace(const Connector2& f) const;
    bool hasEdge(const Connector1& e) const;
    const CellData* father() const {
      if (father_.begin()==father_.end()) {
  return 0;
      }
      else return father_.begin()->second;
    }
    ConnectorData fathers() const { return father_; }
    const CellData* father(uint i) const;
    const ConnectorData fathers(uint i) const;
    void addFather(const CellData* father);
    int related(const CellData& c) const {
      return cell_.related(c.cell()); }
    Key key() const { return cell_.key(); }
  private:
    const Connector& cell_;
    ConnectorData father_;
    ConnectorData cntrData_;
  };

  std::ostream& operator<<(std::ostream& os, const CellData& c);

  // ************************************************************** FaceData **

  class FaceData : public ConnectorData {
    friend std::ostream& operator<<(std::ostream& os, const FaceData& f);
  public:
    FaceData(const Connector2& face) : face_(face) {}
    const Connector2& face() const { return face_; }
    int related(const FaceData& f) const {
      return face_.related(f.face()); }
    Key key() const { return face_.key(); }
    static void checkRelatedFaces(std::map<uint, FaceData>& faceList);
  private:
    const Connector2& face_;
  };

  // ************************************************************** EdgeData **

  class EdgeData : public ConnectorData {
    friend std::ostream& operator<<(std::ostream& os, const EdgeData& e);
  public:
    EdgeData(const Connector1& edge) : edge_(edge), io_(false) {}
    const Connector1& edge() const { return edge_; }
    int related(const EdgeData& e) const {
      return edge_.related(e.edge()); }
    void addFace(const FaceData& f);
    static bool doCheckRelations(std::map<uint, EdgeData>& edgeList);
    bool checkRelations();
    Key key() const { return edge_.key(); }
    static void checkRelatedEdges(std::map<uint, EdgeData>& edgeList);
  private:
    const Connector1& edge_;
    bool io_;
    std::map<uint, FaceData> faces_;
    void recreateFaceList_();
    const CellData* findCommonCell_(const FaceData& face) const;
  };

  // ************************************************************ VertexData **

  class VertexData : public ConnectorData {
    friend std::ostream& operator<<(std::ostream& os, const VertexData& e);
  public:
    VertexData(const Connector0& vertex) : vertex_(vertex), io_(false) {}
    const Connector0& vertex() const { return vertex_; }
    void addEdge(const EdgeData& e);
    static bool doCheckRelations(std::map<uint, VertexData>& vertexList);
    bool checkRelations();
    Key key() const { return vertex_.key(); }
  private:
    const Connector0& vertex_;
    bool io_;
    std::map<uint, EdgeData> edges_;
    void recreateEdgeList_();
    const CellData* findCommonCell_(const EdgeData& edge) const;
  };

  // ******************************************************* EdgesOfVertices **

  class EdgesOfVertices : public HashMap<Set<Connector1*> > {
  public:
    EdgesOfVertices() {}
    EdgesOfVertices(const concepts::Connector2& cell);
    void addCell(const concepts::Connector2& cell);
  };

} // namespace concepts

#endif // continuityData_hh