Mesh.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: Mesh.hpp,v 1.27 2008/03/04 00:17:58 delpinux Exp $

#ifndef MESH_HPP
#define MESH_HPP

#include <Vector.hpp>

#include <ReferenceCounting.hpp>

#include <VerticesSet.hpp>
#include <VerticesCorrespondance.hpp>

#include <EdgesSet.hpp>

#include <Cell.hpp>
#include <Edge.hpp>

#include <string>

template <typename MeshType>
class MeshExtractor;

class Mesh
{
public:
  typedef enum {
    cartesianHexahedraMesh,
    hexahedraMesh,
    octreeMesh,
    tetrahedraMesh,
    trianglesMesh,
    spectralMesh,
    surfaceMeshTriangles,
    surfaceMeshQuadrangles,
  } Type;

  typedef enum {
    volume,
    surface,
    plane
  } Family;

private:
  template <typename MeshType>
  friend class MeshExtractor;

  size_t static __getNextMeshId()
  {
    static size_t nextId = 0;
    return nextId++;
  }

  const Type __type;            
  const Family __family;        
  const size_t __meshId;        
protected:

  template <typename MeshType,
            typename CellType = typename MeshType::CellType>
  class T_iterator
  {
  protected:
    MeshType* __mesh;
    CellType* __iterator;
    size_t __number;

  public:
    typedef enum {
      Begin,
      End
    } Position;

    const size_t& number() const
    {
      return __number;
    }

    inline CellType& operator*()
    {
      return *__iterator;
    }

    inline CellType* pointer() const
    {
      return __iterator;
    }

    inline bool end() const
    {
      return (__number >= __mesh->numberOfCells());
    }

    inline bool operator<(const T_iterator<MeshType, CellType>& i) const
    {
      return (__number < i.__number);
    }

    virtual T_iterator<MeshType, CellType>&
    operator=(const T_iterator<MeshType, CellType>& i)
    {
      __mesh = i.__mesh;
      __iterator = i.__iterator;
      __number = i.__number;

      return *this;
    }

    virtual T_iterator<MeshType, CellType>&
    operator=(CellType* iterator)
    {
      __iterator = iterator;
      __number = static_cast<size_t>(__iterator-&(__mesh->cell(0)));

      return *this;
    }

    inline T_iterator<MeshType, CellType> operator++(int)
    {
      T_iterator<MeshType, CellType> i = *this;
      ++(*this);
      return i;
    }

    inline T_iterator<MeshType, CellType> operator++()
    {
      for(;;) {
        ++__number;
        if (this->end()) {
          break;
        }
        ++__iterator;
        if (not(__iterator->isFictitious())) {
          break;
        }
      }
      return *this;
    }

    T_iterator(MeshType& m,
               T_iterator::Position position = T_iterator::Begin)
      : __mesh(&m),
        __iterator(0),
        __number(0)
    {
      if ((m.numberOfCells() == 0)
          or (position == T_iterator<MeshType, CellType>::End)) {
        __number = __mesh->numberOfCells();
      } else {
        __iterator = & m.cell(0);
        if (__iterator->isFictitious()) {
          ++(*this);
        }
      }
    }

    T_iterator(MeshType& m,
               const size_t& cellNumber)
      : __mesh(&m),
        __iterator(0),
        __number(cellNumber)
    {
      if (cellNumber < m.numberOfCells()) {
        __iterator = & m.cell(cellNumber);
      }
    }

    T_iterator(const T_iterator<MeshType, CellType>& i)
      : __mesh(i.__mesh),
        __iterator(i.__iterator),
        __number(i.__number)
    {
      ;
    }

    virtual ~T_iterator()
    {
      ;
    }
  };

  ReferenceCounting<VerticesSet>
  __verticesSet;                
  ReferenceCounting<VerticesCorrespondance>
  __verticesCorrespondance;     
  ReferenceCounting<EdgesSet>
  __edgesSet;                   
  Mesh(const Mesh& mesh)
    : __type(mesh.__type),
      __family(mesh.__family),
      __meshId(mesh.__meshId),
      __verticesSet(mesh.__verticesSet)
  {
    ;
  }

public:

  virtual bool hasBorderMesh() const = 0;

  virtual ConstReferenceCounting<Mesh> borderBaseMesh() const = 0;


  virtual bool isPeriodic() const
  {
    return __verticesSet->numberOfVertices() != __verticesCorrespondance->numberOfCorrespondances();
  }

  virtual std::string typeName() const = 0;

  virtual bool inside(const real_t& x,
                      const real_t& y,
                      const real_t& z) const =0;

  virtual bool inside(const TinyVector<3, real_t>& p) const = 0;

  const Mesh::Type& type() const
  {
    return __type;
  }

  const Mesh::Family& family() const
  {
    return __family;
  }

  const size_t& id() const
  {
    return __meshId;
  }

  inline size_t vertexNumber(const Vertex& v) const
  {
    return __verticesSet->number(v);
  }

  bool hasEdges() const
  {
    return __edgesSet != 0;
  }

  virtual void buildFaces() = 0;

  virtual bool hasFaces() const = 0;

  virtual void buildEdges() = 0;

  inline size_t edgeNumber(const Edge& e) const
  {
    ASSERT(__edgesSet != 0);
    return __edgesSet->number(e);
  }

  inline const size_t& numberOfVertices() const
  {
    return __verticesSet->numberOfVertices();
  }

  inline void setNumberOfVertices(const size_t& size)
  {
    if (__verticesSet == 0) {
      __verticesSet = new VerticesSet(size);
      __verticesCorrespondance = new VerticesCorrespondance(size);
    } else {
      __verticesSet->setNumberOfVertices(size);
      __verticesCorrespondance = new VerticesCorrespondance(size);
    }
  }

  virtual const size_t& numberOfCells() const = 0;

  inline size_t numberOfEdges() const
  {
    ASSERT(__edgesSet != 0);
    return __edgesSet->numberOfEdges();
  }

  inline ReferenceCounting<VerticesSet> verticesSet()
  {
    return __verticesSet;
  }

  inline ConstReferenceCounting<VerticesSet> verticesSet() const
  {
    return __verticesSet;
  }

  inline ReferenceCounting<VerticesCorrespondance> verticesCorrespondance()
  {
    return __verticesCorrespondance;
  }

  inline ConstReferenceCounting<VerticesCorrespondance> verticesCorrespondance() const
  {
    return __verticesCorrespondance;
  }

  inline const Vertex& vertex(const size_t& i) const
  {
    return (*__verticesSet)[i];
  }

  inline Vertex& vertex(const size_t& i)
  {
    return (*__verticesSet)[i];
  }

  inline const size_t& correspondance(const size_t& i) const
  {
    return (*__verticesCorrespondance)[i];
  }

  inline const Edge&
  edge(const size_t& i) const
  {
    return (*__edgesSet)[i];
  }

  inline Edge& edge(const size_t& i)
  {
    return (*__edgesSet)[i];
  }

  Mesh(const Mesh::Type& type,
       const Mesh::Family& family,
       const size_t& numberOfVertices)
    : __type(type),
      __family(family),
      __meshId(Mesh::__getNextMeshId()),
      __verticesSet(new VerticesSet(numberOfVertices)),
      __verticesCorrespondance(new VerticesCorrespondance(numberOfVertices)),
      __edgesSet(0)
  {
    ;
  }

  Mesh(const Mesh::Type& type,
       const Mesh::Family& family,
       ReferenceCounting<VerticesSet> vertices,
       ReferenceCounting<VerticesCorrespondance> correspondance)
    : __type(type),
      __family(family),
      __meshId(Mesh::__getNextMeshId()),
      __verticesSet(vertices),
      __verticesCorrespondance(correspondance),
      __edgesSet(0)
  {
    ;
  }

  virtual ~Mesh()
  {
    ;
  }
};

#endif // MESH_HPP

---