xref: /dports/math/xlife++/xlifepp-sources-v2.0.1-2018-05-09/src/geometry/geometries3D.hpp

/*
  XLiFE++ is an extended library of finite elements written in C++
  Copyright (C) 2014  Lunéville, Eric; Kielbasiewicz, Nicolas; Lafranche, Yvon; Nguyen, Manh-Ha; Chambeyron, Colin

  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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
 */

/*!
  \file geometries3D.hpp
  \authors Y. Lafranche, N. Kielbasiewicz
  \since 18 oct 2012
  \date 30 jul 2015

  \brief Definition of the classes corresponding to 3D canonical geometrical shapes.

  Geometries are separated into 3 categories :
  - Curves
  - Surfaces
  - Volumes

  It is quite easy to find in which category a geometry is, according to their mathematical
  definition, but they are some exceptions :
  - Cylinder and Cone are surfaces but can also represent volumes inside
  - Ellipse is a closed curve or the surface inside (whereas there is the
    distinction Circle / Disk)
  - Ellipsoid is a closed surface or the volume inside (whereas there is the
    distinction Sphere / Ball)

  It becomes all the more tricky than if we respect the geometrical hierarchy, we will derive a
  prism (semantically 3D) from a cylinder (2D or 3D) or a pyramid (semantically 3D) from a cone.
  Another example is the general definition of a cylinder, from a surface and an axis : it supposes
  that the basis is a surface. But ellipses are supposed to be curves !!!

  This is the reason why we chose to defines ellipses as surfaces, ellipsoids as volumes (coherence) and cylinders
  and cones as volumes.

*/

#ifndef GEOMETRIES_3D_HPP
#define GEOMETRIES_3D_HPP

#include "Geometry.hpp"

namespace xlifepp
{

/*!
  \class Volume
  base class for 3D geometries
*/
class Volume : public Geometry
{
  public:
    //! default constructor for 3D geometries
    Volume();

  protected:
    //@{
    //! true constructor functions
    void buildParam(const Parameter& p);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    Volume(const Volume& v) : Geometry(v) {} //!< copy constructor
    virtual Geometry* clone() const { return new Volume(*this); } //!< virtual copy constructor for Geometry
    virtual ~Volume() {} //!< virtual destructor

    //! format as string
    virtual string_t asString() const { error("shape_not_handled", words("shape",shape_)); return string_t(); }

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Volume
    virtual Volume& transform(const Transformation& t);
    //! apply a translation on a Volume (vector version)
    virtual Volume& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Volume (3 reals version)
    virtual Volume& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Volume
    virtual Volume& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Volume
    virtual Volume& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                             real_t angle = 0.);
    //! apply a rotation on a Volume
    virtual Volume& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Volume
    virtual Volume& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Volume
    virtual Volume& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Volume
    virtual Volume& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Volume
    virtual Volume& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Volume
    virtual Volume& homothetize(real_t factor);
    //! apply a point reflection on a Volume
    virtual Volume& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Volume
    virtual Volume& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Volume
    virtual Volume& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Volume
    virtual Volume& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Volume
    virtual Volume& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Polyhedron
  definition of a polyhedral geometry in R^3
  Generally, a polyhedron is a list of polygonal faces. But data is storages differently to avoid pointer manipulation
  So, we decide to store :
  - the list of vertices -> Vector<Point> p_
  - the definition of faces as a list of points -> Vector<Vector<number_t> > faces_
    it is so that p_[faces_[i][j]] is the j-st vertex of the i-st face of the polyhedron
  - the number of nodes on each edge -> Vector<Vector<number_t> > n_
    it is so that n_[i][j] is the number of nodes on j-st edge [ p_[faces_[i][j]] p_[faces_[i][j+1]] ] of the i-st face
    of the polyhedron
 */
class Polyhedron : public Volume
{
  protected:
    std::vector<Polygon*> faces_; //!< faces of the polyhedron
    std::vector<Point> p_;        //!< vertices of the polyhedron
    std::vector<number_t> n_;     //!< number of nodes on each edge
    std::vector<real_t> h_;       //!< local mesh step on each vertex

  public:
    //! default constructor
    Polyhedron();
    //! constructor with 1 Parameter
    Polyhedron(const Parameter& p1);
    //! constructor with 2 Parameter
    Polyhedron(const Parameter& p1, const Parameter& p2);

  protected:
    //@{
    //! true constructor functions
    void buildP();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Polyhedron(const Polyhedron& ph);
    //! destructor
    virtual ~Polyhedron()
    {
      for (number_t i = 0; i < faces_.size(); ++i) delete faces_[i];
      faces_.clear();
    }

    //! accessor to vertices
    std::vector<Point> p() const { return p_; }
    //! accessor to vertex i
    Point p(number_t i) const { return p_[i-1]; }
    //! accessor to faces
    std::vector<Polygon*> faces() const { return faces_; }
    //! accessor to number of faces
    number_t nbFaces() const { return faces_.size(); }

    //! accessor to number of nodes on edge i
    number_t nOnEdge(number_t i, number_t j) const { return faces_[i-1]->n(j); }

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Polyhedron(*this); } //!< virtual copy constructor

    bool withNnodes() const { return (h_.size() == 0); } //!< check if Polyhedron is defined only with _nnodes or with _hsteps option

    virtual std::vector<const Point*> boundNodes() const; //!< returns list of points on boundary (const)
    virtual std::vector<Point*> nodes(); //!< returns list of every point (non const)
    virtual std::vector<const Point*> nodes() const; //!< returns list of every point (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of edges
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    virtual number_t nbSides() const { return faces_.size(); } //!< returns the number of sides
    virtual void setFaces()             //! set the faces vector when built
      {error("not_handled","Polyhedron::setFaces()");}
    virtual void collect(const string_t& n, std::list<Geometry*>&) const; //!< collect in a list all canonical geometry's with name n

    //! computes the minimal box
    virtual void computeMB() { minimalBox = MinimalBox(boundingBox.bounds()); }

    //! access to child Polyhedron object (const)
    virtual const Polyhedron* polyhedron() const {return this;}
    //! access to child Polyhedron object
    virtual Polyhedron* polyhedron() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Polyhedron
    virtual Polyhedron& transform(const Transformation& t);
    //! apply a translation on a Polyhedron (vector version)
    virtual Polyhedron& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Polyhedron (3 reals version)
    virtual Polyhedron& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                 real_t angle = 0.);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Polyhedron
    virtual Polyhedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Polyhedron
    virtual Polyhedron& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Polyhedron
    virtual Polyhedron& homothetize(real_t factor);
    //! apply a point reflection on a Polyhedron
    virtual Polyhedron& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Polyhedron
    virtual Polyhedron& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Polyhedron
    virtual Polyhedron& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Polyhedron
    virtual Polyhedron& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Polyhedron
    virtual Polyhedron& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Tetrahedron
  definition of a tetrahedron geometry in R^3
 */
class Tetrahedron : public Polyhedron
{
  public:
    //! default constructor
    Tetrahedron();
    //! constructor with 4 Parameter
    Tetrahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Tetrahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Tetrahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6);
    //! constructor with 3 Parameter
    Tetrahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7);

  private:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! accessor to number of nodes on edge i
    number_t n(number_t i) const { return n_[i-1]; }
    //! accessor to local steps
    std::vector<real_t> h() const {return h_;}
    //! accessor to local step on vertex i (read only)
    real_t h(number_t i) const { return h_[i-1];}

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Tetrahedron(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of edges
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    virtual number_t nbSides() const { return 4; } //!< returns the number of sides
    virtual void setFaces();                       //!< set the faces vector when built
    real_t measure() const;

    //! computes the minimal box
    virtual void computeMB() { minimalBox=MinimalBox(p_[0],p_[1],p_[2],p_[3]); }

    //! access to child Tetrahedron object (const)
    virtual const Tetrahedron* tetrahedron() const {return this;}
    //! access to child Tetrahedron object
    virtual Tetrahedron* tetrahedron() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Tetrahedron
    virtual Tetrahedron& transform(const Transformation& t);
    //! apply a translation on a Tetrahedron (vector version)
    virtual Tetrahedron& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Tetrahedron (3 reals version)
    virtual Tetrahedron& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                  real_t angle = 0.);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Tetrahedron
    virtual Tetrahedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Tetrahedron
    virtual Tetrahedron& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Tetrahedron
    virtual Tetrahedron& homothetize(real_t factor);
    //! apply a point reflection on a Tetrahedron
    virtual Tetrahedron& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Tetrahedron
    virtual Tetrahedron& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Tetrahedron
    virtual Tetrahedron& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Tetrahedron
    virtual Tetrahedron& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Tetrahedron
    virtual Tetrahedron& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Hexahedron
  definition of a hexahedron geometry in R^3
 */
class Hexahedron : public Polyhedron
{
  public:
    //! default constructor
    Hexahedron();
    //! constructor with 4 Parameter
    Hexahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
               const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 5 Parameter
    Hexahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
               const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);
    //! constructor with 6 Parameter
    Hexahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
               const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10);
    //! constructor with 3 Parameter
    Hexahedron(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
               const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
               const Parameter& p11);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! accessor to number of nodes on edge i
    number_t n(number_t i) const { return n_[i-1]; }
    //! accessor to local steps
    std::vector<real_t> h() const {return h_;}
    //! accessor to local step on vertex i (read only)
    real_t h(number_t i) const { return h_[i-1];}

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Hexahedron(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of edges
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    virtual number_t nbSides() const { return 8; } //!< returns the number of sides
    virtual void setFaces();                       //!< set the faces vector when built

    //! access to child Hexahedron object (const)
    virtual const Hexahedron* hexahedron() const {return this;}
    //! access to child Hexahedron object
    virtual Hexahedron* hexahedron() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Hexahedron
    virtual Hexahedron& transform(const Transformation& t);
    //! apply a translation on a Hexahedron (vector version)
    virtual Hexahedron& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Hexahedron (3 reals version)
    virtual Hexahedron& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                 real_t angle = 0.);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Hexahedron
    virtual Hexahedron& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Hexahedron
    virtual Hexahedron& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Hexahedron
    virtual Hexahedron& homothetize(real_t factor);
    //! apply a point reflection on a Hexahedron
    virtual Hexahedron& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Hexahedron
    virtual Hexahedron& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Hexahedron
    virtual Hexahedron& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Hexahedron
    virtual Hexahedron& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Hexahedron
    virtual Hexahedron& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Parallelepiped
  definition of a parallelepiped geometry in R^3
 */
class Parallelepiped : public Hexahedron
{
  public:
    //! default constructor
    Parallelepiped();
    //! constructor with 4 Parameter
    Parallelepiped(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Parallelepiped(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Parallelepiped(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                   const Parameter& p6);
    //! constructor with 7 Parameter
    Parallelepiped(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                   const Parameter& p6, const Parameter& p7);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! returns number of nodes on edges 1, 3, 5 and 7
    number_t n1() const {return n(1);}
    //! returns number of nodes on edges 2, 4, 6 and 8
    number_t n2() const {return n(2);}
    //! retusn number of nodes on edges 9, 10, 11 and 12
    number_t n3() const {return n(9);}

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Parallelepiped(*this); } //!< virtual copy constructor

    virtual void setFaces();                                                             //!< set the faces vector when built
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    real_t measure() const;

    //! computes the minimal box
    virtual void computeMB() { minimalBox= MinimalBox(p_[0],p_[1],p_[3],p_[4]); }

    //! access to child Parallelepiped object (const)
    virtual const Parallelepiped* parallelepiped() const {return this;}
    //! access to child Parallelepiped object
    virtual Parallelepiped* parallelepiped() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Parallelepiped
    virtual Parallelepiped& transform(const Transformation& t);
    //! apply a translation on a Parallelepiped (vector version)
    virtual Parallelepiped& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Parallelepiped (3 reals version)
    virtual Parallelepiped& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                     real_t angle = 0.);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Parallelepiped
    virtual Parallelepiped& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Parallelepiped
    virtual Parallelepiped& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Parallelepiped
    virtual Parallelepiped& homothetize(real_t factor);
    //! apply a point reflection on a Parallelepiped
    virtual Parallelepiped& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Parallelepiped
    virtual Parallelepiped& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Parallelepiped
    virtual Parallelepiped& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Parallelepiped
    virtual Parallelepiped& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Parallelepiped
    virtual Parallelepiped& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Cuboid
  definition of a cuboid (=rectangular parallelepiped) geometry in R^3
 */
class Cuboid : public Parallelepiped
{
  protected:
    // initialized when rectangle defined with center or origin keys
    Point center_, origin_;
    // true when corresponding key group is given
    bool isCenter_, isOrigin_;
    // initialized when rectangle defined with center or origin keys
    real_t xlength_, ylength_, zlength_;
  private:
    // initialized when rectangle defined with xmin, xmax, ymin, ymax keys
    real_t xmin_, xmax_, ymin_, ymax_, zmin_, zmax_;
    // true when corresponding key group is given
    bool isBounds_;

  public:
    //! default constructor
    Cuboid();
    //! constructor with 4 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
              const Parameter& p6);
    //! constructor with 7 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
           const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
           const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    Cuboid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
           const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);

  protected:
    //@{
    //! true constructor functions
    void buildP();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Cuboid(const Cuboid& c);
    //! returns number of nodes on edges 1, 3, 5 and 7
    number_t nx() const {return n(1);}
    //! returns number of nodes on edges 2, 4, 6 and 8
    number_t ny() const {return n(2);}
    //! retusn number of nodes on edges 9, 10, 11 and 12
    number_t nz() const {return n(9);}

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Cuboid(*this); } //!< virtual copy constructor

    virtual void setFaces();                                      //!< set the faces vector when built
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    real_t measure() const { return xlength_*ylength_*zlength_; }

    //! computes the minimal box
    virtual void computeMB() { minimalBox= MinimalBox(p_[0],p_[1],p_[3],p_[4]); }

    //! access to child Cuboid object (const)
    virtual const Cuboid* cuboid() const {return this;}
    //! access to child Cuboid object
    virtual Cuboid* cuboid() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Cuboid
    virtual Cuboid& transform(const Transformation& t);
    //! apply a translation on a Cuboid (vector version)
    virtual Cuboid& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Cuboid (3 reals version)
    virtual Cuboid& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                             real_t angle = 0.);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cuboid
    virtual Cuboid& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Cuboid
    virtual Cuboid& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Cuboid
    virtual Cuboid& homothetize(real_t factor);
    //! apply a point reflection on a Cuboid
    virtual Cuboid& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Cuboid
    virtual Cuboid& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Cuboid
    virtual Cuboid& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Cuboid
    virtual Cuboid& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Cuboid
    virtual Cuboid& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class Cube
   A cube is defined by its center and the length of its edges.
 */
class Cube : public Cuboid
{
  private:
    dimen_t nboctants_; //!< number of octants to be filled in the 3D space

  public:
    //! default constructor
    Cube();
    //! constructor with 2 Parameter
    Cube(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Cube(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Cube(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Cube(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Cube(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6);
    //! constructor with 7 Parameter
    Cube(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6, const Parameter& p7);

  private:
    //@{
    //! true constructor functions
    void buildP();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Cube(const Cube& c);
    //! format as string
    virtual string_t asString() const;

    // access functions to data members
    Point center()  const { return center_; } //!< returns center
    real_t edgeLen() const { return xlength_; } //!< returns edge length
    std::vector<std::pair<real_t, dimen_t> > rotations() const //! returns rotations
    { return trihedralOrientation(p_[0], p_[1], p_[3], p_[4]); }

    virtual dimen_t nbOctants() const { return nboctants_; } //!< returns number of octants
    virtual number_t nbSubdiv() const; //!< returns number of subdivision

    virtual Geometry* clone() const { return new Cube(*this); } //!< virtual copy constructor

    virtual void setFaces();                                    //!< set the faces vector when built
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    real_t measure() const { return xlength_*ylength_*zlength_/8.*nboctants_; }

    //! access to child Cube object (const)
    virtual const Cube* cube() const {return this;}
    //! access to child Cube object
    virtual Cube* cube() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Cube
    virtual Cube& transform(const Transformation& t);
    //! apply a translation on a Cube (vector version)
    virtual Cube& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Cube (3 reals version)
    virtual Cube& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Cube
    virtual Cube& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Cube
    virtual Cube& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                           real_t angle = 0.);
    //! apply a rotation on a Cube
    virtual Cube& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cube
    virtual Cube& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Cube
    virtual Cube& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cube
    virtual Cube& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Cube
    virtual Cube& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Cube
    virtual Cube& homothetize(real_t factor);
    //! apply a point reflection on a Cube
    virtual Cube& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Cube
    virtual Cube& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Cube
    virtual Cube& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Cube
    virtual Cube& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Cube
    virtual Cube& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Ellipsoid
  definition of an ellipsoidal geometry in R^3 (volume)
 */
class Ellipsoid : public Volume
{
  protected:
    Point center_;   //!< center of the ellipsoid
    Point p1_;  //!< first apogee of the ellipsoid
    Point p2_;  //!< second apogee of the ellipsoid
    Point p3_;  //!< first perigee of the ellipsoid
    Point p4_;  //!< second perigee of the ellipsoid
    Point p5_;  //!< third perigee of the ellipsoid
    Point p6_;  //!< third apogee of the ellipsoid
    real_t xlength_, ylength_, zlength_;
    bool isAxis_;

    number_t n1_;   //!< number of nodes on edge [p1_ p2_]
    number_t n2_;   //!< number of nodes on edge [p2_ p3_]
    number_t n3_;   //!< number of nodes on edge [p3_ p4_]
    number_t n4_;   //!< number of nodes on edge [p4_ p1_]
    number_t n5_;   //!< number of nodes on edge [p1_ p6_]
    number_t n6_;   //!< number of nodes on edge [p6_ p3_]
    number_t n7_;   //!< number of nodes on edge [p3_ p5_]
    number_t n8_;   //!< number of nodes on edge [p5_ p1_]
    number_t n9_;   //!< number of nodes on edge [p2_ p6_]
    number_t n10_;  //!< number of nodes on edge [p6_ p4_]
    number_t n11_;  //!< number of nodes on edge [p4_ p5_]
    number_t n12_;  //!< number of nodes on edge [p5_ p2_]
    std::vector<real_t> h_; //!< local mesh step on each vertex of the ellipsoid

    dimen_t nboctants_; //!< number of octants to be filled in the 3D space
    dimen_t type_;     //!< indicator to fit curved boundaries (default) or not which gives flat (or plane) boundaries

  public:
    //! default constructor
    Ellipsoid();
    //! constructor with 4 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6);
    //! constructor with 7 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    Ellipsoid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);

  protected:
    //@{
    //! true constructor functions
    void buildP();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Ellipsoid(const Ellipsoid& e);

    //@{
    //! accessor to point
    Point center() const { return center_;}
    Point p1() const { return p1_;}
    Point p2() const { return p2_;}
    Point p3() const { return p3_;}
    Point p4() const { return p4_;}
    Point p5() const { return p5_;}
    Point p6() const { return p6_;}
    //@}

    //@{
    //! accessor to number of nodes on edge
    number_t n1() const {return n1_;}
    number_t n2() const {return n2_;}
    number_t n3() const {return n3_;}
    number_t n4() const {return n4_;}
    number_t n5() const {return n5_;}
    number_t n6() const {return n6_;}
    number_t n7() const {return n7_;}
    number_t n8() const {return n8_;}
    number_t n9() const {return n9_;}
    number_t n10() const {return n10_;}
    number_t n11() const {return n11_;}
    number_t n12() const {return n12_;}
    //@}

    //! accessor to local steps
    std::vector<real_t> h() const {return h_;}
    //! accessor to local step on vertex i (read only)
    real_t h(number_t i) const { return h_[i-1];}

    real_t length1() const { return xlength_; } //!< return first axis length
    real_t length2() const { return ylength_; } //!< return second axis length
    real_t length3() const { return zlength_; } //!< return third axis length
    std::vector<std::pair<real_t, dimen_t> > rotations() const //! returns rotations
    { return trihedralOrientation(center_, p1_, p2_, p6_); }
    virtual dimen_t nbOctants() const { return nboctants_; } //!< returns number of octants
    virtual number_t nbSubdiv() const; //!< returns number of subdivisions
    virtual dimen_t type() const { return type_; } //!< return type of subdivision

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Ellipsoid(*this); } //!< virtual copy constructor

    bool withNnodes() const { return (h_.size() == 0); } //!< check if Ellipsoid is defined only with _nnodes or with _hsteps option

    virtual std::vector<const Point*> boundNodes() const; //!< returns list of points on boundary (const)
    virtual std::vector<Point*> nodes(); //!< returns list of every point (non const)
    virtual std::vector<const Point*> nodes() const; //!< returns list of every point (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of edges
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces
    virtual number_t nbSides() const { return 8; } //!< returns the number of sides
    real_t measure() const;

    //! computes the minimal box
    virtual void computeMB()
    { minimalBox= MinimalBox(4.*center_-p1_-p2_-p6_, 2.*center_+p1_-p2_-p6_, 2.*center_+p2_-p1_-p6_, 2.*center_+p6_-p1_-p2_); }

    //! access to child Ellipsoid object (const)
    virtual const Ellipsoid* ellipsoid() const {return this;}
    //! access to child Ellipsoid object
    virtual Ellipsoid* ellipsoid() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Ellipsoid
    virtual Ellipsoid& transform(const Transformation& t);
    //! apply a translation on a Ellipsoid (vector version)
    virtual Ellipsoid& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Ellipsoid (3 reals version)
    virtual Ellipsoid& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                real_t angle = 0.);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Ellipsoid
    virtual Ellipsoid& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Ellipsoid
    virtual Ellipsoid& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Ellipsoid
    virtual Ellipsoid& homothetize(real_t factor);
    //! apply a point reflection on a Ellipsoid
    virtual Ellipsoid& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Ellipsoid
    virtual Ellipsoid& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Ellipsoid
    virtual Ellipsoid& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Ellipsoid
    virtual Ellipsoid& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Ellipsoid
    virtual Ellipsoid& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class Ball
   A sphere is defined by its center and radius.
   Rotations may be additionnaly defined to orient the axes of the ball. This is useful for the subdivision algorithm
   when only a portion of the ball is considered.
 */
class Ball : public Ellipsoid
{
  public:
    //! default constructor
    Ball();
    //! constructor with 2 Parameter
    Ball(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6);
    //! constructor with 7 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    Ball(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
         const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Ball(const Ball& b);
    //! format as string : "Ball (center=(.,.,.), radius = R)"
    virtual string_t asString() const;

    // access functions to data members
    real_t radius() const { return xlength_/2.; }  //!< returns radius

    virtual Geometry* clone() const { return new Ball(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of edges
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces

    //! access to child Ball object (const)
    virtual const Ball* ball() const {return this;}
    //! access to child Ball object
    virtual Ball* ball() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Ball
    virtual Ball& transform(const Transformation& t);
    //! apply a translation on a Ball (vector version)
    virtual Ball& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Ball (3 reals version)
    virtual Ball& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Ball
    virtual Ball& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Ball
    virtual Ball& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                           real_t angle = 0.);
    //! apply a rotation on a Ball
    virtual Ball& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Ball
    virtual Ball& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Ball
    virtual Ball& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Ball
    virtual Ball& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Ball
    virtual Ball& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Ball
    virtual Ball& homothetize(real_t factor);
    //! apply a point reflection on a Ball
    virtual Ball& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Ball
    virtual Ball& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Ball
    virtual Ball& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Ball
    virtual Ball& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Ball
    virtual Ball& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

typedef Ball Sphere;

/*!
  \class Trunk
  A Trunk is a volume defined by a cylinder or a trunk of cone. A cylinder is a trunk of a cylinder !!!
  To define it, we need a basis, a translation and a homothety to build the other basis.
  To make it more simple, we will need a basis, the first point of the other basis (determining the translation
  and the center of the homothety), and a scale factor. This "first point" of a basis is defined as basis.p(1) : it is
  the first vertex for a polygon, but the center for an ellipse or a disk
 */
class Trunk : public Volume
{
  protected:
    //! first surfacic basis
    Surface * basis_;
    //! scale factor
    real_t scale_;
    //! points used to define the geometry
    std::vector<Point> p_;
    //! number of nodes on edges
    std::vector<number_t> n_;
    //! local mesh step on each vertex of the cylinder
    std::vector<real_t> h_;
    Point origin_, center1_, p1_, p2_;
    bool isElliptical_, isN_;

  public:
    //! default constructor
    Trunk(real_t scale=1, bool defineBasisAndP=true);
    //! constructor with 3 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6);
    //! constructor with 7 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    Trunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6, const Parameter& p7, const Parameter& p8);

  protected:
    //@{
    //! true constructor functions
    void buildPAndBasis();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Trunk(const Trunk& t);
    //! destructor
    virtual ~Trunk() { if (basis_ != 0) { delete basis_; } }

    //! accessor to points
    std::vector<Point> p() const { return p_; }
    //! accessor to point i
    Point p(number_t i) const { return p_[i-1]; }
    //! accessor to number of nodes (read only)
    std::vector<number_t> n() const { return n_; }
    //! accessor to number of nodes on edge i (read only)
    number_t n(number_t i) const { return n_[i-1]; }
    //! accessor to local steps
    std::vector<real_t> h() const {return h_;}
    //! accessor to local step on vertex i (read only)
    real_t h(number_t i) const { return h_[i-1];}
    //! accessor to basis of trunk
    Surface* basis() const { return basis_; }
    //! accessor to scale factor of trunk
    real_t scale() const { return scale_; }
    //! accessor to origin_ of trunk
    Point origin() const { return origin_; }
    //! accessor to origin_ of trunk
    Point center1() const { return center1_; }
    //! accessor to origin_ of trunk
    Point center2() const { return origin_; }
    //! accessor to origin_ of trunk
    Point p1() const { return p1_; }
    //! accessor to origin_ of trunk
    Point p2() const { return p2_; }

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Trunk(*this); } //!< virtual copy constructor

    bool withNnodes() const { return (h_.size() == 0); } //!< check if Trunk is defined only with _nnodes or with _hsteps option

    virtual std::vector<const Point*> boundNodes() const; //!< returns list of points on boundary (const)
    virtual std::vector<Point*> nodes(); //!< return list of every point (non const)
    virtual std::vector<const Point*> nodes() const; //!< returns list of every point (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of curves (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)
    virtual number_t nbSides() const { return basis_->nbSides()+2; } //!< returns the number of sides
    real_t measure() const;

    virtual void computeMB()
    {
      minimalBox= MinimalBox(basis_->minimalBox.boundPt(1),
                             basis_->minimalBox.boundPt(2),
                             basis_->minimalBox.boundPt(3),
                             basis_->minimalBox.boundPt(1)+origin_-basis_->p(1));
    }

    //! access to child Trunk object (const)
    virtual const Trunk* trunk() const {return this;}
    //! access to child Trunk object
    virtual Trunk* trunk() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Trunk
    virtual Trunk& transform(const Transformation& t);
    //! apply a translation on a Trunk (vector version)
    virtual Trunk& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Trunk (3 reals version)
    virtual Trunk& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                            real_t angle = 0.);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Trunk
    virtual Trunk& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Trunk
    virtual Trunk& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Trunk
    virtual Trunk& homothetize(real_t factor);
    //! apply a point reflection on a Trunk
    virtual Trunk& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Trunk
    virtual Trunk& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Trunk
    virtual Trunk& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Trunk
    virtual Trunk& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Trunk
    virtual Trunk& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class Cylinder
   A cylinder is a volume defined by a section (the basis) and a direction vector
   The direction vector is not necessarily orthogonal to the basis, but both bases are necessarily parallel
   A Cylinder is a Trunk with scale factor equal to 1 !!!
 */
class Cylinder : public Trunk
{
  protected:
    //! direction vector
    Point dir_;

  public:
    //! default constructor
    Cylinder(bool defineBasisAndP=true);
    //! default constructor with basis and direction
    Cylinder(const Surface& basis, const std::vector<real_t>& direction);
    //! constructor with 2 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
             const Parameter& p6);
    //! constructor with 7 Parameter
    Cylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
             const Parameter& p6, const Parameter& p7);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Cylinder(const Cylinder& c);

    //! accessor to direction vector
    Point dir() const { return dir_; }

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Cylinder(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)

    virtual void computeMB()
    {
      minimalBox= MinimalBox(basis_->minimalBox.boundPt(1),
                             basis_->minimalBox.boundPt(2),
                             basis_->minimalBox.boundPt(3),
                             basis_->minimalBox.boundPt(1)+dir_);
    }

    //! access to child Cylinder object (const)
    virtual const Cylinder* cylinder() const {return this;}
    //! access to child Cylinder2d object
    virtual Cylinder* cylinder() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Cylinder
    virtual Cylinder& transform(const Transformation& t);
    //! apply a translation on a Cylinder (vector version)
    virtual Cylinder& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Cylinder (3 reals version)
    virtual Cylinder& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                               real_t angle = 0.);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cylinder
    virtual Cylinder& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Cylinder
    virtual Cylinder& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Cylinder
    virtual Cylinder& homothetize(real_t factor);
    //! apply a point reflection on a Cylinder
    virtual Cylinder& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Cylinder
    virtual Cylinder& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Cylinder
    virtual Cylinder& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Cylinder
    virtual Cylinder& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Cylinder
    virtual Cylinder& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Prism
  definition of a prismatic geometry in R^3
 */
class Prism : public Cylinder
{
  private:
    bool isTriangular_;
    Point p3_;

  public:
    //! default constructor
    Prism();
    //! constructor with 2 Parameter
    Prism(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Prism(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Prism(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Prism(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Prism(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6);
    //! constructor with 7 Parameter
    Prism(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6, const Parameter& p7);

  protected:
    //@{
    //! true constructor functions
    void buildPBasisNAndH();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Prism(const Prism& p);
    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Prism(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)
    virtual void collect(const string_t& n, std::list<Geometry*>&) const; //!< collect all canonical geometry's with name n

    //! access to child Prism object (const)
    virtual const Prism* prism() const {return this;}
    //! access to child Prism object
    virtual Prism* prism() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Prism
    virtual Prism& transform(const Transformation& t);
    //! apply a translation on a Prism (vector version)
    virtual Prism& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Prism (3 reals version)
    virtual Prism& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Prism
    virtual Prism& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Prism
    virtual Prism& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                            real_t angle = 0.);
    //! apply a rotation on a Prism
    virtual Prism& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Prism
    virtual Prism& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Prism
    virtual Prism& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Prism
    virtual Prism& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Prism
    virtual Prism& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Prism
    virtual Prism& homothetize(real_t factor);
    //! apply a point reflection on a Prism
    virtual Prism& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Prism
    virtual Prism& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Prism
    virtual Prism& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Prism
    virtual Prism& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Prism
    virtual Prism& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class Cone
   A cylinder is a volume defined by a section (the basis) and a direction vector
   The direction vector is not necessarily orthogonal to the basis, but both bases are necessarily parallel
   A Cylinder is a Trunk with scale factor equal to 0 !!!
 */
class Cone : public Trunk
{
  public:
    //! default constructor
    Cone(bool defineBasisAndP=true);
    //! default constructor with basis and apex
    Cone(const Surface& basis, const Point& apex);
    //! constructor with 2 Parameter
    Cone(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Cone(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Cone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Cone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Cone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6);
    //! constructor with 7 Parameter
    Cone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
          const Parameter& p6, const Parameter& p7);

  protected:
    //@{
    //! true constructor functions
    void buildPBasisNAndH();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Cone(const Cone& c);

    //! accessor to apex_
    Point apex() const { return origin_; }

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Cone(*this); } //!< virtual copy constructor

    virtual std::vector<const Point*> boundNodes() const; //!< returns list of points on boundary (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of curves (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)

    virtual void computeMB()
    {
      minimalBox= MinimalBox(basis_->minimalBox.boundPt(1),
                             basis_->minimalBox.boundPt(2),
                             basis_->minimalBox.boundPt(3),
                             origin_);
    }

    //! access to child Cone object (const)
    virtual const Cone* cone() const {return this;}
    //! access to child Cone2d object
    virtual Cone* cone() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Cone
    virtual Cone& transform(const Transformation& t);
    //! apply a translation on a Cone (vector version)
    virtual Cone& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Cone (3 reals version)
    virtual Cone& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Cone
    virtual Cone& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Cone
    virtual Cone& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                           real_t angle = 0.);
    //! apply a rotation on a Cone
    virtual Cone& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cone
    virtual Cone& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Cone
    virtual Cone& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Cone
    virtual Cone& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Cone
    virtual Cone& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Cone
    virtual Cone& homothetize(real_t factor);
    //! apply a point reflection on a Cone
    virtual Cone& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Cone
    virtual Cone& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Cone
    virtual Cone& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Cone
    virtual Cone& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Cone
    virtual Cone& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
  \class Pyramid
  definition of a pyramidal geometry in R^3
 */
class Pyramid : public Cone
{
  private:
    bool isQuadrangular_;
    Point p3_, p4_;

  public:
    //! default constructor
    Pyramid();
    //! constructor with 2 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2);
    //! constructor with 3 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6);
    //! constructor with 7 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    Pyramid(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8);

  protected:
    //@{
    //! true constructor functions
    void buildPBasisNAndH();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    Pyramid(const Pyramid& p);

    //@{
    //! accessor to point
    Point p1() const { return p_[0]; }
    Point p2() const { return p_[1]; }
    Point p3() const { return p_[2]; }
    Point p4() const { return p_[3]; }
    Point p5() const { return p_[4]; }
    //@}

    //@{
    //! accessor to number of element on edge
    number_t n1() const {return n_[0];}
    number_t n2() const {return n_[1];}
    number_t n3() const {return n_[2];}
    number_t n4() const {return n_[3];}
    number_t n5() const {return n_[4];}
    number_t n6() const {return n_[5];}
    number_t n7() const {return n_[6];}
    number_t n8() const {return n_[7];}
    //@}

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new Pyramid(*this); } //!< virtual copy constructor

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)
    virtual void collect(const string_t& n, std::list<Geometry*>&) const; //!< collect in a all canonical geometry's with name n

    //! access to child Pyramid object (const)
    virtual const Pyramid* pyramid() const {return this;}
    //! access to child Pyramid object
    virtual Pyramid* pyramid() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a Pyramid
    virtual Pyramid& transform(const Transformation& t);
    //! apply a translation on a Pyramid (vector version)
    virtual Pyramid& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a Pyramid (3 reals version)
    virtual Pyramid& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                              real_t angle = 0.);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a Pyramid
    virtual Pyramid& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a Pyramid
    virtual Pyramid& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a Pyramid
    virtual Pyramid& homothetize(real_t factor);
    //! apply a point reflection on a Pyramid
    virtual Pyramid& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a Pyramid
    virtual Pyramid& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a Pyramid
    virtual Pyramid& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a Pyramid
    virtual Pyramid& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a Pyramid
    virtual Pyramid& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class RevTrunk
   A object of revolution is defined by its axis (P1,P2) and the radii of two circles
   obtained by intersection with a plane orthogonal to (P1,P2). The object is delimited
   by the two planes, orthogonal to (P1,P2), passing by P1 and P2, and this is the default
   end shape of the object when it is meshed with volumic elements (gesFlat or equivalently
   in this case, gesNone).
   When the elements are surfacic, the default is to leave the ends empty (gesNone).

   Moreover, on both ends of this object, one can add part of a cone (gesCone), an ellipsoid
   (gesEllipsoid) or a sphere (gesSphere), connected to the boundary circle of the object.
   Let us consider the boundary circle whose center is P1. The apex of the cone or the ellipsoid
   is assumed to lie on the line (P1,P2) at a given distance distance1_ from P1. This distance
   is irrelevant in the case of the sphere. The same apply on the other end of the object.
   When the elements are surfacic, one can additonnaly chose a flat "lid" (gesFlat) ; the
   distance argument is then also irrelevant in this case.
 */
class RevTrunk : public Trunk
{
  protected:
    real_t radius1_, radius2_;
    number_t nbSubDomains_;       //!< number of main subDomains
    GeometricEndShape endShape1_; //!< shape of the first end
    real_t distance1_;            //!< height of the first end
    GeometricEndShape endShape2_; //!< shape of the second end
    real_t distance2_;            //!< height of the second end
    dimen_t type_;                //!< type of the subdivision

  public:
    //! default constructor
    RevTrunk(real_t scale=1., bool defineBasisAndP=true);
    //! constructor with 4 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
             const Parameter& p6);
    //! constructor with 7 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
             const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);
    //! constructor with 10 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10);
    //! constructor with 11 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
            const Parameter& p11);
    //! constructor with 12 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
            const Parameter& p11, const Parameter& p12);
    //! constructor with 13 Parameter
    RevTrunk(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
            const Parameter& p11, const Parameter& p12, const Parameter& p13);

  protected:
    //@{
    //! true constructor functions
    void buildP();
    void buildPScaleAndBasis();
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! copy constructor
    RevTrunk(const RevTrunk& r);
    //! format as string : "RevTrunk (P1=(.,.,.), P2=(.,.,.), radius=R, end1=., end2=., d1=., d2=.)"
    virtual string_t asString() const;

    real_t radius1() const { return radius1_; }   //!< returns radius of first basis
    real_t radius2() const { return radius2_; }        //!< returns radius of second basis
    GeometricEndShape endShape1() const { return endShape1_; } //!< returns shape of first end
    GeometricEndShape endShape2() const { return endShape2_; } //!< returns shape of second end
    real_t distance1() const { return distance1_; }            //!< returns height of first end
    real_t distance2() const { return distance2_; }            //!< returns height of second end

    virtual number_t nbSubdomains() const { return nbSubDomains_; }        //!< returns number of elements on lateral edges
    virtual number_t nbSubdiv() const; //!< returns number of subdivisions
    virtual dimen_t type() const { return type_; }  //!< returns type of subdivision

    virtual Geometry* clone() const { return new RevTrunk(*this); } //!< virtual copy constructor

    //! access to child RevTrunk object (const)
    virtual const RevTrunk* revTrunk() const {return this;}
    //! access to child RevTrunk object
    virtual RevTrunk* revTrunk() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a RevTrunk
    virtual RevTrunk& transform(const Transformation& t);
    //! apply a translation on a RevTrunk (vector version)
    virtual RevTrunk& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a RevTrunk (3 reals version)
    virtual RevTrunk& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                               real_t angle = 0.);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevTrunk
    virtual RevTrunk& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a RevTrunk
    virtual RevTrunk& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a RevTrunk
    virtual RevTrunk& homothetize(real_t factor);
    //! apply a point reflection on a RevTrunk
    virtual RevTrunk& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a RevTrunk
    virtual RevTrunk& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a RevTrunk
    virtual RevTrunk& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a RevTrunk
    virtual RevTrunk& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a RevTrunk
    virtual RevTrunk& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class RevCylinder
   A cylinder of revolution is defined by its axis (P1,P2) and the radius of any circle
   obtained by intersection with a plane orthogonal to (P1,P2).
   See more details at RevTrunk.
 */
class RevCylinder : public RevTrunk
{
  public:
    //! default constructor
    RevCylinder();
    //! constructor with 3 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6);
    //! constructor with 7 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);
    //! constructor with 10 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10);
    //! constructor with 11 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
                const Parameter& p11);
    //! constructor with 12 Parameter
    RevCylinder(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10,
                const Parameter& p11, const Parameter& p12);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new RevCylinder(*this); } //!< virtual copy constructor

    //! computes the minimal box
    virtual void computeMB()
    {
      minimalBox= MinimalBox(basis_->minimalBox.boundPt(1), basis_->minimalBox.boundPt(2), basis_->minimalBox.boundPt(3),
                             basis_->minimalBox.boundPt(1)+origin_-center1_);
    }

    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)

    //! access to child RevCylinder object (const)
    virtual const RevCylinder* revCylinder() const {return this;}
    //! access to child RevCylinder object
    virtual RevCylinder* revCylinder() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a RevCylinder
    virtual RevCylinder& transform(const Transformation& t);
    //! apply a translation on a RevCylinder (vector version)
    virtual RevCylinder& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a RevCylinder (3 reals version)
    virtual RevCylinder& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                                  real_t angle = 0.);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevCylinder
    virtual RevCylinder& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a RevCylinder
    virtual RevCylinder& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a RevCylinder
    virtual RevCylinder& homothetize(real_t factor);
    //! apply a point reflection on a RevCylinder
    virtual RevCylinder& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a RevCylinder
    virtual RevCylinder& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a RevCylinder
    virtual RevCylinder& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a RevCylinder
    virtual RevCylinder& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a RevCylinder
    virtual RevCylinder& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

/*!
   \class RevCone
   A truncated cone of revolution is defined by its axis (P1,P2) and two radii R1 and R2.
   R1 (resp. R2) is the radius of the circle lying in the plane orthogonal to (P1,P2) passing
   by P1 (resp. P2).
   R1 (or R2) can be 0, in which case we get a cone of revolution.
   See more details at RevTrunk.
 */
class RevCone : public RevTrunk
{
  public:
    //! default constructor
    RevCone();
    //! constructor with 3 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3);
    //! constructor with 4 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4);
    //! constructor with 5 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5);
    //! constructor with 6 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
                const Parameter& p6);
    //! constructor with 7 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7);
    //! constructor with 8 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8);
    //! constructor with 9 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9);
    //! constructor with 10 Parameter
    RevCone(const Parameter& p1, const Parameter& p2, const Parameter& p3, const Parameter& p4, const Parameter& p5,
            const Parameter& p6, const Parameter& p7, const Parameter& p8, const Parameter& p9, const Parameter& p10);

  protected:
    //@{
    //! true constructor functions
    void build(const std::vector<Parameter>& ps);
    void buildParam(const Parameter& gp);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
    //@}

  public:
    //! accessor to apex_
    Point apex() const { return origin_; }

    //! format as string
    virtual string_t asString() const;

    virtual Geometry* clone() const { return new RevCone(*this); } //!< virtual copy constructor

    virtual std::vector<const Point*> boundNodes() const; //!< returns list of points on boundary (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const; //!< returns list of curves (const)
    virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const; //!< returns list of faces (const)

    virtual void computeMB()
    {
      minimalBox= MinimalBox(basis_->minimalBox.boundPt(1),
                             basis_->minimalBox.boundPt(2),
                             basis_->minimalBox.boundPt(3),
                             origin_);
    }

    //! access to child RevCone object (const)
    virtual const RevCone* revCone() const {return this;}
    //! access to child RevCone object
    virtual RevCone* revCone() {return this;}

    //================================================
    //         transformations facilities
    //================================================
    //! apply a geometrical transformation on a RevCone
    virtual RevCone& transform(const Transformation& t);
    //! apply a translation on a RevCone (vector version)
    virtual RevCone& translate(std::vector<real_t> u = std::vector<real_t>(3,0.));
    //! apply a translation on a RevCone (3 reals version)
    virtual RevCone& translate(real_t ux, real_t uy = 0., real_t uz = 0.);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate2d(const Point& c = Point(0.,0.), real_t angle = 0.);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> d = std::vector<real_t>(3,0.),
                              real_t angle = 0.);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate3d(real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate3d(real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate3d(const Point& c, real_t dx, real_t dy, real_t angle);
    //! apply a rotation on a RevCone
    virtual RevCone& rotate3d(const Point& c, real_t dx, real_t dy, real_t dz, real_t angle);
    //! apply a homothety on a RevCone
    virtual RevCone& homothetize(const Point& c = Point(0.,0.,0.), real_t factor = 1.);
    //! apply a homothety on a RevCone
    virtual RevCone& homothetize(real_t factor);
    //! apply a point reflection on a RevCone
    virtual RevCone& pointReflect(const Point& c = Point(0.,0.,0.));
    //! apply a reflection2d on a RevCone
    virtual RevCone& reflect2d(const Point& c = Point(0.,0.), std::vector<real_t> d = std::vector<real_t>(2,0.));
    //! apply a reflection2d on a RevCone
    virtual RevCone& reflect2d(const Point& c, real_t dx, real_t dy = 0.);
    //! apply a reflection3d on a RevCone
    virtual RevCone& reflect3d(const Point& c = Point(0.,0.,0.), std::vector<real_t> n = std::vector<real_t>(3,0.));
    //! apply a reflection3d on a RevCone
    virtual RevCone& reflect3d(const Point& c, real_t nx, real_t ny, real_t nz = 0.);
};

} // end of namespace xlifepp

#endif // GEOMETRIES_3D_HPP