MeshOfHexahedra.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: MeshOfHexahedra.hpp,v 1.22 2008/03/04 00:17:58 delpinux Exp $

#ifndef MESH_OF_HEXAHEDRA_HPP
#define MESH_OF_HEXAHEDRA_HPP

#include <Mesh.hpp>

#include <SurfaceMeshOfQuadrangles.hpp>
#include <FacesSet.hpp>

#include <Hexahedron.hpp>

#include <Connectivity.hpp>
#include <Octree.hpp>

#include <list>
#include <map>

class MeshOfHexahedra
  : public Mesh
{
public:
  typedef Hexahedron CellType;
  typedef Hexahedron::FaceType FaceType;

  typedef MeshOfHexahedra Transformed;

  typedef SurfaceMeshOfQuadrangles BorderMeshType;

  enum {
    family = Mesh::volume
  };
private:
  ReferenceCounting<Vector<Hexahedron> > __cells; 
  ReferenceCounting<BorderMeshType>
  __borderMesh; 
  ReferenceCounting<FacesSet<Quadrangle> >
  __facesSet;  
  Connectivity<MeshOfHexahedra> __connectivity; 
  ReferenceCounting<Octree<size_t, 3> > __octree; 
  TinyVector<3,real_t> __a;     
  TinyVector<3,real_t> __b;     
  MeshOfHexahedra(const MeshOfHexahedra& m);

public:
  std::string typeName() const
  {
    return "unstructured mesh of hexahedra";
  }

  inline bool inside(const real_t& x, const real_t& y, const real_t& z) const
  {
    return not(this->find(x, y, z).end());
  }

  inline bool inside(const TinyVector<3>& p) const
  {
    return this->inside(p[0], p[1], p[2]);
  }

  inline bool hasBorderMesh() const
  {
    return (__borderMesh != 0);
  }

  ConstReferenceCounting<BorderMeshType> borderMesh() const
  {
    return __borderMesh;
  }

  ConstReferenceCounting<Mesh> borderBaseMesh() const
  {
    return static_cast<const BorderMeshType*>(__borderMesh);
  }

  void buildEdges();

  bool hasFaces() const
  {
    return (__facesSet != 0);
  }

  void buildFaces();

  const FaceType& face(const size_t& i) const
  {
    return (*__facesSet)[i];
  }

  size_t faceNumber(const FaceType& f) const
  {
    return (*__facesSet).number(f);
  }

  inline const size_t& numberOfFaces() const
  {
    return (*__facesSet).numberOfFaces();
  }

  inline const size_t& numberOfCells() const
  {
    return (*__cells).size();
  }

  size_t cellNumber(const Hexahedron& h) const
  {
    return (*__cells).number(h);
  }

  typedef Mesh::T_iterator<MeshOfHexahedra, Hexahedron> iterator;
  typedef Mesh::T_iterator<const MeshOfHexahedra, const Hexahedron> const_iterator;

  void buildLocalizationTools();

  MeshOfHexahedra::const_iterator find(const double& x,
                                       const double& y,
                                       const double& z) const;

  MeshOfHexahedra::const_iterator find(const TinyVector<3>& X) const
  {
    return find(X[0], X[1], X[2]);
  }

  inline Hexahedron& cell(const size_t& i)
  {
    return (*__cells)[i];
  }

  inline const Hexahedron& cell(const size_t& i) const
  {
    return (*__cells)[i];
  }

  const Connectivity<MeshOfHexahedra>& connectivity() const
  {
    return __connectivity;
  }

  Connectivity<MeshOfHexahedra>& connectivity()
  {
    return __connectivity;
  }

  MeshOfHexahedra(const size_t& numberOfVertices,
                  const size_t& numberOfCells)
    : Mesh(Mesh::hexahedraMesh,
           Mesh::volume,
           numberOfVertices), 
      __cells(new Vector<Hexahedron>(numberOfCells)),
      __borderMesh(0),
      __facesSet(0),
      __connectivity(*this)
  {
    this->buildLocalizationTools();
  }

  MeshOfHexahedra(ReferenceCounting<VerticesSet> vertices,
                  ReferenceCounting<VerticesCorrespondance> correspondances,
                  ReferenceCounting<Vector<Hexahedron> > hexahedra,
                  ReferenceCounting<BorderMeshType> borderMesh)
    : Mesh(Mesh::hexahedraMesh,
           Mesh::volume,
           vertices,
           correspondances),
      __cells(hexahedra),
      __borderMesh(borderMesh),
      __facesSet(0),
      __connectivity(*this)
  {
    this->buildLocalizationTools();
  }

  MeshOfHexahedra(ReferenceCounting<VerticesSet> vertices,
                  ReferenceCounting<VerticesCorrespondance> correspondances,
                  ReferenceCounting<Vector<Hexahedron> > hexahedra)
    : Mesh(Mesh::hexahedraMesh,
           Mesh::volume,
           vertices,
           correspondances),
      __cells(hexahedra),
      __borderMesh(0),
      __facesSet(0),
      __connectivity(*this)
  {
    this->buildLocalizationTools();
  }

  ~MeshOfHexahedra()
  {
    ;
  }
};

#endif // MESH_OF_HEXAHEDRA_HPP

---