Cell.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: Cell.hpp,v 1.12 2007/05/20 23:02:47 delpinux Exp $


#ifndef CELL_HPP
#define CELL_HPP

#include <Vertex.hpp>

#include <Stringify.hpp>
#include <ErrorHandler.hpp>
 
class Cell {
public:
  enum Type {
    hexahedron,
    cartesianHexahedron,
    hexahedronByEdge,
    tetrahedron,
    triangle3d,
    quadrangle3d
  };

protected:
  size_t __reference;

  real_t __volume;

  Vertex** __vertices;

  mutable bool __isFictitious;

public:
  inline bool find(const Vertex * P) {
    for(size_t i=0 ; i<numberOfVertices() ; ++i) {
      if(__vertices[i]==P) {
        return true;
      }
    }
    return false;
  }

  inline const real_t& volume() const
  {
    return __volume;
  }

  inline void replace(Vertex* v0, Vertex* v1)
  {
    for (size_t i = 0; i<numberOfVertices(); ++i) {
      if (__vertices[i] == v0) {
        __vertices[i] = v1;
        return;
      }
    }

    const std::string errorMsg
      = "vertex "+stringify(v0)+" was not found while replacing "+stringify(v1);

    throw ErrorHandler(__FILE__,__LINE__,
                       errorMsg,
                       ErrorHandler::unexpected);
  }

  const bool& isFictitious() const
  {
    return __isFictitious;
  }

  void setFictitious(const bool& b) const
  {
    __isFictitious = b;
  }

  virtual size_t numberOfVertices() const = 0;

  virtual Cell::Type type() const = 0;

  inline const size_t& reference() const
  {
    return __reference;
  }

  inline size_t& reference()
  {
    return __reference;
  }

  inline Vertex& operator () (const size_t& i)
  {
    ASSERT (i<numberOfVertices());
    return *__vertices[i];
  }

  inline const Vertex& operator () (const size_t& i) const
  {
    ASSERT (i<numberOfVertices());
    return *(__vertices[i]);
  }

  inline const Cell& operator=(const Cell& C)
  {
    __reference = C.__reference;
    __volume = C.__volume;

    for (size_t i=0; i<C.numberOfVertices(); ++i)
      __vertices[i] = C.__vertices[i];

    return *this;
  }

  Cell(const size_t& numberOfVertices)
    : __reference(0),
      __volume(0),
      __isFictitious(false)
  {
    ASSERT(numberOfVertices > 0);
    __vertices = new Vertex*[numberOfVertices];
  }

  Cell(const size_t& numberOfVertices, const size_t& reference)
    : __reference(reference),
      __volume(0),
      __isFictitious(false)
  {
    ASSERT(numberOfVertices > 0);
    __vertices = new Vertex*[numberOfVertices];
  }

  Cell(const Cell& C)
    : __reference(C.__reference),
      __volume(C.__volume),
      __isFictitious(C.__isFictitious)
  {
    __vertices = new Vertex*[C.numberOfVertices()];
    for (size_t i=0; i<C.numberOfVertices(); ++i)
      __vertices[i] = C.__vertices[i];
  }

  virtual ~Cell()
  {
    delete [] __vertices;
  }
};

#endif // CELL_HPP

---