Cell.h

Go to the documentation of this file.

// Copyright (C) 2002 Johan Hoffman and Anders Logg.
// Licensed under the GNU GPL Version 2.

// A couple of comments:
//
//   - Enums don't need to be called "refined_regular", just "regular" is enough?
//   - Move data to GenericCell? Cell should only contain the GenericCell pointer?
//   - Maybe more methods should be private?

#ifndef __CELL_H
#define __CELL_H

#include <dolfin/dolfin_log.h>
#include <dolfin/Array.h>
#include <dolfin/CellIterator.h>
#include <dolfin/NodeIterator.h>
#include <dolfin/EdgeIterator.h>
#include <dolfin/FaceIterator.h>

namespace dolfin
{
  
  class Point;
  class Node;
  class Edge;
  class Triangle;
  class Tetrahedron;
  class Mesh;
  class MeshInit;
  class CellRefData;
  
  class Cell
  {
  public:

    enum Type { triangle, tetrahedron, none };

    Cell();

    Cell(Node& n0, Node& n1, Node& n2);

    Cell(Node& n0, Node& n1, Node& n2, Node& n3);

    ~Cell();

    void clear();


    int id() const;

    Type type() const;

    int noNodes() const;

    int noEdges() const;

    int noFaces() const;

    int noBoundaries() const;

    int noCellNeighbors() const;

    int noNodeNeighbors() const;

    int noChildren() const;

    Node& node(int i) const;

    Edge& edge(int i) const;

    Face& face(int i) const;

    Cell& neighbor(int i) const;

    Cell* parent() const;

    Cell* child(int i) const;

    Point& coord(int i) const;

    Point midpoint() const;

    // Return id for node number i
    int nodeID(int i) const;
    
    // Compute and return volume / area
    real volume() const;

    // Compute and return diameter 
    real diameter() const;

    bool operator==(const Cell& cell) const;

    bool operator!=(const Cell& cell) const;
    

    void mark();
    

    friend LogStream& operator<<(LogStream& stream, const Cell& cell);
    
    // Friends
    friend class Mesh;
    friend class MeshData;
    friend class MeshInit;
    friend class MeshRefinement;
    friend class MeshRefinementData;
    friend class TriMeshRefinement;
    friend class TetMeshRefinement;
    friend class GenericCell;
    friend class CellRefData;
    friend class NodeIterator::CellNodeIterator;
    friend class CellIterator::CellCellIterator;
    friend class EdgeIterator::CellEdgeIterator;
    friend class FaceIterator::CellFaceIterator;
    
  private:
    
    enum Marker { marked_for_reg_ref,        // Marked for regular refinement
                  marked_for_irr_ref_1,      // Marked for irregular refinement by rule 1
                  marked_for_irr_ref_2,      // Marked for irregular refinement by rule 2
                  marked_for_irr_ref_3,      // Marked for irregular refinement by rule 3
                  marked_for_irr_ref_4,      // Marked for irregular refinement by rule 4
                  marked_for_no_ref,         // Marked for no refinement
                  marked_for_coarsening,     // Marked for coarsening
                  marked_according_to_ref }; // Marked according to refinement
    
    enum Status { ref_reg,                   // Refined regularly
                  ref_irr,                   // Refined irregularly
                  unref };                   // Unrefined
    
    // Specify global cell number
    int setID(int id, Mesh& mesh);
    
    // Set the mesh pointer
    void setMesh(Mesh& mesh);

    // Set parent cell
    void setParent(Cell& parent);

    // Remove parent cell
    void removeParent();

    // Set number of children
    void initChildren(int n);

    // Set child cell
    void addChild(Cell& child);

    // Remove child cell
    void removeChild(Cell& child);

    // Clear data and create a new triangle
    void set(Node& n0, Node& n1, Node& n2);

    // Clear data and create a new tetrahedron
    void set(Node& n0, Node& n1, Node& n2, Node& n3);

    // Check if given cell is a neighbor
    bool neighbor(Cell& cell) const;

    // Check if given node is contained in the cell
    bool haveNode(Node& node) const;

    // Check if given edge is contained in the cell
    bool haveEdge(Edge& edge) const;

    // Create edges for the cell
    void createEdges();

    // Create faces for the cell
    void createFaces();

    // Create a given edge
    void createEdge(Node& n0, Node& n1);

    // Create a given face
    void createFace(Edge& e0, Edge& e1, Edge& e2);

    // Find node with given coordinates (null if not found)
    Node* findNode(const Point& p) const;
       
    // Find edge within cell (null if not found)
    Edge* findEdge(Node& n0, Node& n1);

    // Find face within cell (null if not found)
    Face* findFace(Edge& e0, Edge& e1, Edge& e2);
    Face* findFace(Edge& e0, Edge& e1);

    // Return cell marker
    Marker& marker();

    // Return cell status
    Status& status();

    //--- Cell data ---

    // The cell
    GenericCell* c;
    
  };

}

#endif

Documentation automatically generated with Doxygen on 10 Sep 2004.