inputs/dev/Geometry.tex

%%%%%%%%%%%%%%%%%%%
% 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/>.
%%%%%%%%%%%%%%%%%%%

\section{Defining geometries}

Whatever the geometry is, the common characteristics are a dimension, a shape, a name, a bounding box and a more convenient box for geometry inclusion than the previous one, and easier to define than the convex hull, the so-called "minimal box". This is the reason why we define 3 classes : {\class BoundingBox}, {\class MinimalBox} and {\class Geometry}.

\subsection{{\classtitle BoundingBox} and {\classtitle MinimalBox} classes}

The bounding box is the smallest box whose faces are parallel to axis containing the geometry. As a segment in 1D, a rectangle in 2D or a parallelepiped in 3D, it can be defined from 2, 3 or 4 points, as illustrated in the following figure :

\begin{figure}[H]
\begin{center}
\inputTikZ{box}
\end{center}
\caption{Definition of a box from points}
\label{fig.boxdef}
\end{figure}

For example, if we define a segment whose boundaries are the points $A(0,0,-1)$ and $B(1,2,3)$, the bounding box is $[0;1]\times[0;2]\times[-1;3]$. The {\class BoundingBox} class is then defined as a vector of pairs of real numbers :

\begin{lstlisting}
typedef std::pair<Real, Real> RealPair;
class BoundingBox
{
  private :
    std::vector<RealPair> bounds_; //!< Bounding values of the box [xmin,xmax]x[ymin,ymax]x[zmin,zmax]
\end{lstlisting}

It offers a various list of constructors, from set of real pairs or set of {\class Point} :

\begin{lstlisting}[deletekeywords={[3] vp}]
BoundingBox() {}
BoundingBox(const std::vector<RealPair>&);
BoundingBox(Real, Real, Real, Real, Real, Real);
BoundingBox(Real, Real, Real, Real);
BoundingBox(Real, Real);
BoundingBox(const Point&, const Point&, const Point&, const Point&);
BoundingBox(const Point&, const Point&, const Point&);
BoundingBox(const Point&, const Point&);
BoundingBox(const std::vector<Point>& vp);
\end{lstlisting}

There is also :

\begin{itemize}
\item a various list of accessors :
\begin{lstlisting}
std::vector<RealPair> bounds() const; // return bounds in all direction
RealPair bounds(Dimen i) const;   // return bounds in direction i (1 to dim)
RealPair xbounds() const;         // return bounds in first direction
RealPair ybounds() const;         // return bounds in second direction
RealPair zbounds() const;         // return bounds in third direction
Point minPoint() const;           // return the min point (left,bottom,front)
Point maxPoint() const;           // return the max point (right,top,back)
\end{lstlisting}
\item print facilities :
\begin{lstlisting}
void print(std::ostream&) const; // print BoundingBox
String asString() const;         // format as string : [a,b]x[c,d]x[e,f]

std::ostream& operator<<(std::ostream&, const BoundingBox&); //output box
std::ostream& operator<<(std::ostream&, const RealPair&); //output pair of reals
\end{lstlisting}

\item some utility functions, such as merging 2 bounding boxes or giving its dimension :
\begin{lstlisting}
Dimen dim() const; // dimension of the bounding box
BoundingBox& operator +=(const BoundingBox&); // merge a bounding box
\end{lstlisting}
\end{itemize}

As the segment example shows, the dimension of the geometry and the dimension of the bounding box are independent. So if we want to check if a geometry is inside another geometry, this is not the right box to use, if we want to be independent of the true shape of the geometry. That is why the {\class MinimalBox} class is defined :

\begin{lstlisting}
class MinimalBox
{
  protected :
    std::vector<Point> bounds_;
\end{lstlisting}
You can notice that it is {\class Point} that are stored, and only the 2, 3 or 4 points necessary to define the box, as shown in \autoref{fig.boxdef}

The {\class MinimalBox} class offers quite the same constructors as the {\class BoundingBox} class :
\begin{lstlisting}
MinimalBox() {}
MinimalBox(const std::vector<Point>&);
MinimalBox(const std::vector<RealPair>&);
MinimalBox(Real, Real, Real, Real, Real, Real);
MinimalBox(Real, Real, Real, Real);
MinimalBox(Real, Real);
MinimalBox(const Point&, const Point&, const Point&, const Point&);
MinimalBox(const Point&, const Point&, const Point&);
MinimalBox(const Point&, const Point&);
\end{lstlisting}

It also offers :
\begin{itemize}
\item some accessors :
\begin{lstlisting}
std::vector<Point> bounds() const;
Point boundPt(Dimen i) const; // return bounds in direction i (1 to dim)
Point minPoint() const;
Point maxPoint() const;
\end{lstlisting}
\item print facilities :
\begin{lstlisting}
void print(std::ostream&) const;
String asString() const;


std::ostream& operator<<(std::ostream&, const MinimalBox&); // output MinimalBox
\end{lstlisting}
\item some utility functions, the same as in {\class BoundingBox}, plus a function to return all vertices of the box, not only the points stored in {\var bounds\_}.
\begin{lstlisting}
Dimen dim() const;
MinimalBox& operator +=(const MinimalBox&);
std::vector<Point> vertices() const;
\end{lstlisting}
\end{itemize}

\begin{remark}
A minimal box of a segment will always be a segment.
A minimal box of a 2D plane geometry will always be a rectangle.
\end{remark}

\medskip

Now that both boxes classes are clarified, we can now look at the main class : {\class Geometry}.

\subsection{The {\classtitle Geometry} class}

A geometry can be of 3 natures : canonical geometries, such as {\class Rectangle} or {\class Ball}, so-called "loop" geometries defined by its set of geometrical boundaries, and so-called "composite" geometries defined by union of elementary geometries and holes. The definition of the {\class Geometry} class takes into account these different natures :

\begin{lstlisting}[deletekeywords={[3] name, map}]
enum ShapeType
{
  _noshape=0,
  _point ,
  _segment, segment=_segment,
  _triangle, triangle=_triangle,
  _quadrangle, quadrangle=_quadrangle,
  _tetrahedron, tetrahedron=_tetrahedron,
  _hexahedron, hexahedron=_hexahedron,
  _prism, prism=_prism,
  _pyramid, pyramid=_pyramid,
  _ellArc, _circArc,
  _polygon, _parallelogram, _rectangle, _square, _ellipse, _disk, _ellipsoidPart, _spherePart,
  _setofelems, _trunkPart, _cylinderPart, _conePart,
  _polyhedron, _parallelepiped, _cuboid, _cube, _ellipsoid, _ball, _trunk,
  _revTrunk, _cylinder, _revCylinder, _cone, _revCone,
  _composite, _loop, _extrusion
};

class Geometry
{
  public:
    BoundingBox boundingBox;
    MinimalBox minimalBox;
    mutable bool force; // tag to force inclusion when geometry engines fails
    mutable bool crackable; // tag to define if the geometry should be cracked or not
  protected:
    string_t domName_;   // geometry name
    Dimen dim_;       // physical space dimension
    ShapeType shape_; // geometrical shape
    std::vector<string_t> sideNames_; //names of sides (boundaries)
    std::vector<string_t> theNamesOfVariables_; // variable names (x,y,z),...
    string_t teXFilename_;                      // name of the file containing the tex code drawing the geometry
  private:
    mutable std::map<number_t, Geometry*> components_; // for composite/loop geometry
    std::map<number_t, std::vector<number_t> > geometries_; // for composite geometry
    std::map<number_t, std::vector<number_t> > loops_; // for loop geometry
    mutable Transformation* extrusion_; // for extrusion geometry
    number_t layers_; // for extrusion geometry
\end{lstlisting}
\vspace{0.2cm}

{\var name} and {\var sideNames\_} are devoted to store domain names or side domain names.

\begin{figure}[H]
\includeTikZPict[width=18cm]{geometries.png}
\caption{{\lib Geometry} child classes}
\label{diag_geometries}
\end{figure}

The {\class Geometry} is the base class for a large set of canonical geometries, so the management of "composite" and "loop" geometries implies 2 main vectors of {\class Geometry} pointers and a set of virtual functions to cast a {\class Geometry} into one of its child :

\begin{lstlisting}[deletekeywords={[3] name}]
//! access to child Xxxxxxx object (const)
virtual const Xxxxxxx* xxxxxxx() const { error("bad_geometry", name, words("shape",shape_), words("shape",_yyyyyyy)); return 0; }
//! access to child Xxxxxxx object
virtual Xxxxxxx* xxxxxxx() { error("bad_geometry", name, words("shape",shape_), words("shape",_yyyyyyy)); return 0; }
\end{lstlisting}

{\tt xxxxxxx} must be one of the following keyword : {\tt segment, ellArc, circArc, polygon, triangle, quadrangle, parallelogram, rectangle, square, ellipse, disk, polyhedron, tetrahedron, hexahedron, parallelepiped, cuboid, cube, ellipsoid, ball, revTrunk, trunk, cylinder, revCylinder, prism, cone, revCone, pyramid, setOfElems }

{\tt yyyyyyy} must be the corresponding {\class ShapeType} item.

\medskip

The {\class Geometry} class offers constructors from {\class BoundingBox}, dimension or both :

\begin{lstlisting}[deletekeywords={[3] name, nx, ny, nz}]
Geometry(): force(false), crackable(false), domName_(""), dim_(0), shape_(_noshape), extrusion_(0), layers_(0) { sideNames_.resize(0); }  // void constructor
Geometry(const Geometry& g);                        // copy constructor
// basic constructor from bounding box
Geometry(const BoundingBox&, const string_t& na = "?", ShapeType sht=_noshape,
     const string_t& nx = "x", const string_t& ny = "y", const string_t& nz = "z");
Geometry(const BoundingBox&, dimen_t, const string_t& na = "?",
     ShapeType sht=_noshape, const string_t& nx = "x", const string_t& ny = "y",
     const string_t& nz = "z");
Geometry(dimen_t, const string_t& na = "?", ShapeType sht=_noshape,
     const string_t& nx = "x", const string_t& ny = "y", const string_t& nz = "z");
virtual ~Geometry()  {}
\end{lstlisting}

It also offers :
\begin{itemize}
\item some accessors :
\begin{lstlisting}[deletekeywords={[3] map}]
dimen_t dim() const;
ShapeType shape() const;
void shape(ShapeType sh);
string_t domName() const;
void domName(const string_t& nm);
string_t teXFilename() const;
void teXFilename(const string_t& fn);
const std::vector<string_t> sideNames() const;
std::vector<string_t> sideNames();
std::map<number_t, Geometry*> components();
const std::map<number_t, Geometry*> components() const;
const std::map<number_t, std::vector<number_t> > geometries() const;
std::map<number_t, std::vector<number_t> > loops() const;
number_t layers() const;
Transformation* extrusion();
const Transformation* extrusion() const;
\end{lstlisting}
\item some print facilities :
\begin{lstlisting}
void print(std::ostream&) const;           //!< print Geometry
friend std::ostream& operator<<(std::ostream&, const Geometry&); //!< output Geometry
\end{lstlisting}
\item some functions to compute or update boxes :
\begin{lstlisting}
virtual void computeMB(); //! compute the minimal box
void updateBB(const std::vector<RealPair>& bb) {boundingBox = BoundingBox(bb);}
\end{lstlisting}
As the minimal box depends on the true shape of the geometry, it is a virtual function reimplemented in child classes.
\item some virtual functions to get data from canonical geometries, such as the vector of points defining the geometry, or the parameters for the subdivision mesh algorithm :
\begin{lstlisting}
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\item member functions to determine if a geometry is coplanar to another geometry or inside another geometry, and external functions or operators to define "composite", "loop" or "extrusions" geometries.
\begin{lstlisting}[deletekeywords={[3] name}]
bool isCoplanar(const Geometry& g) const;
bool isInside(const Geometry&) const; //check if geometry is inside an other one

friend Geometry operator+(const Geometry&, const Geometry&); //union
Geometry& operator+=(const Geometry&);
friend Geometry operator-(const Geometry&, const Geometry&); //difference (hole)
Geometry& operator-=(const Geometry&);

// definition of a geometry 2D/3D from its boundary 1D/2D
friend Geometry surfaceFrom(const Geometry&, String name = "");
friend Geometry volumeFrom(const Geometry&, String name = "");
friend Geometry extrude(const Geometry& g, const Transformation& t, number_t layers, string_t domName, std::vector<string_t> sidenames);
friend Geometry extrude(const Geometry& g, const Transformation& t, number_t layers, std::vector<string_t> sidenames);
\end{lstlisting}

Operators + and - work as follows :
\begin{itemize}
\item if both arguments are canonical geometries (neither "composite" nor "loop"), it puts pointers to them in the {\var components\_} attribute and if one geometry is inside the other, it puts it in the {\var geometries} attribute.
\item If at least one of the argument is "composite" or "loop", it inserts the canonical geometry correctly, or merge the 4 maps.
\end{itemize}

{\cmd surfaceFrom} and {\cmd volumeFrom} allow to define surfaces and respectively volumes from their boundaries, so-called "loop" geometries. The mechanism is the same : taking a "composite" geometry as argument, it puts every component in the {\var borders\_} attribute and defines the loop in the {\var loops\_} attribute, so that we can define "composite" geometries of "loop" geometries, but it is for the moment forbidden.
\end{itemize}

\subsection{{\classtitle Curve}, {\classtitle Surface} and {\classtitle Volume} classes}


The {\class Curve} class is the base class for every canonical 1D geometry. It has no attributes and only general constructors :

\begin{lstlisting}[deletekeywords={[3] name}]
class Curve : public Geometry
{
  public:
    Curve();
  protected:
    void buildParam(const Parameter& p);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();
  public:
    Curve(const Curve& c) : Geometry(c) {} //!< copy constructor
    virtual Geometry* clone() const { return new Curve(*this); } //!< virtual copy constructor for Geometry
    virtual ~Curve() {} //!< virtual destructor
};
\end{lstlisting}

The {\class Surface} class is the base class for every canonical 2D geometry. Actually, it has no attributes and only constructors :

\begin{lstlisting}[deletekeywords={[3] name}]
class Surface : public Geometry
{
  public:
    //! default constructor for 2D geometries
    Surface();

  protected:
    void buildParam(const Parameter& p);
    void buildDefaultParam(ParameterKey key);
    std::set<ParameterKey> getParamsKeys();

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

    virtual std::vector<Point> p() const
    { error("not_yet_implemented","std::vector<Point> Surface::p() const"); return std::vector<Point>(); }
    virtual std::vector<number_t> n() const
    { error("not_yet_implemented","std::vector<Point> Surface::n() const"); return std::vector<number_t>(); }
    virtual Point p(number_t i) const
    { error("not_yet_implemented","Point Surface::p(Number i) const"); return Point(); }
    virtual number_t n(number_t i) const
    { error("not_yet_implemented","Number Surface::n(Number i) const"); return 0; }
    virtual number_t& n(number_t i)
    { error("not_yet_implemented","Number& Surface::n(Number i)"); return *new number_t(0); }
    virtual std::vector<real_t> h() const
    { error("not_yet_implemented","std::vector<Real> Surface::h() const"); return std::vector<real_t>(); }
    virtual real_t h(number_t i) const
    { error("not_yet_implemented","Number Surface::h(Number i) const"); return 0.; }
    virtual real_t& h(number_t i)
    { error("not_yet_implemented","Number& Surface::h(Number i)"); return *new real_t(0); }

    bool isPolygon()
    {
      if (shape_ == _polygon || shape_ == _triangle || shape_ == _quadrangle || shape_ == _parallelogram || shape_ == _rectangle ||
          shape_ == _square) { return true; }
      return false;
    }

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

The {\class Volume} class is the base class for every canonical 3D geometry. Actually, it has no attributes and only constructors :

\begin{lstlisting}[deletekeywords={[3] name}]
class Volume : public Geometry
{
  public:
    //! default constructor for 3D geometries
    Volume();

  protected:
    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(); }
};
\end{lstlisting}

\subsection{Definition of canonical geometries}

In this subsection, we will explain how to define canonical geometries. All constructors for these classes are writtent in the same way : with {\class Parameter} arguments, so that the user can use a key-value system.

\subsubsection{The key-value system}

Some keys are easy to determine : the center for rectangles, squares, ellipses, disks, cuboids, cubes, ellipsoids and balls, the radius for disks, balls, and cylinders, \ldots. To do so, global keys are defined (type {\class Parameter}). Here is the list of available keys with authorized data types and classes using them:

\medskip

\begin{tabular}{|p{3cm}|p{7cm}|p{6cm}|}
\hline
key & authorized types & concerned classes \\
\hline
\hline
\param \_angle1 & single integer or real value & class {\class Disk} \\
\hline
\param \_angle2 & single integer or real value & class {\class Disk} \\
\hline
\param \_apex & single integer or real value, or {\class Point} & classes {\class Cone}, {\class Pyramid}, {\class RevCone} \\
\hline
\param \_apogee & single integer or real value, or {\class Point} & class {\class EllArc} \\
\hline
\hline
\param \_basis & classes {\class Polygon}, {\class Triangle}, {\class Quadrangle}, {\class Parallelogram}, {\class Rectangle}, {\class Square}, {\class Ellipse}, {\class Disk} & classes {\class Trunk}, {\class Cylinder}, {\class Prism}, {\class Cone}, {\class Pyramid} \\
\hline
\hline
\param \_center & single integer or real value, or {\class Point} & classes {\class EllArc}, {\class CircArc}, {\class Rectangle}, {\class Square}, {\class Ellipse}, {\class Disk}, {\class Cuboid}, {\class Cube}, {\class Ellipsoid}, {\class Ball}, {\class RevCone} \\
\hline
\param \_center1 & single integer or real value, or {\class Point} & classes {\class Trunk}, {\class Cylinder}, {\class Cone}, {\class RevTrunk}, {\class RevCylinder} \\
\hline
\param \_center2 & single integer or real value, or {\class Point} & classes {\class Trunk}, {\class Cylinder}, {\class RevTrunk}, {\class RevCylinder} \\
\hline
\hline
\param \_direction & std::vector of real values or {\class Point} & classes {\class Cylinder}, {\class Prism} \\
\hline
\param \_domain\_name & single string & every class \\
\hline
\hline
\param \_end\_shape & enum {\class GeometricEndShape} & class {\class RevCone} \\
\hline
\param \_end1\_shape & enum {\class GeometricEndShape} & classes{\class RevTrunk}, {\class RecCylinder} \\
\hline
\param \_end2\_shape & enum {\class GeometricEndShape} & classes {\class RevTrunk}, {\class RecCylinder} \\
\hline
\param \_end\_distance & single unsigned  integer or real positive value & class {\class RevCone} \\
\hline
\param \_end1\_distance & single unsigned  integer or real positive value & classes {\class RevTrunk}, {\class RecCylinder} \\
\hline
\param \_end2\_distance & single unsigned  integer or real positive value & classes {\class RevTrunk}, {\class RecCylinder} \\
\hline
\hline
\param \_faces & vector of {\class Polygon} & class {\class Polyhedron} \\
\hline
\hline
\param \_hsteps & single real value, std::vector of real values or {\class Reals} & every class but {\class Polyhedron}  \\
\hline
\hline
\param \_length & single unsigned  integer or real positive value & classes {\class Square}, {\class Cube} \\
\hline
\hline
\param \_nboctants & single unsigned integer value & classes {\class Cube}, {\class Ellipsoid}, {\class Ball} \\
\hline
\param \_nbsubdomains & single unsigned integer value & classes {\class RevTrunk}, {\class RevCylinder}, {\class RevCone} \\
\hline
\param \_nnodes & single unsigned integer value, std::vector of integer values  or {\class Numbers} & every class but {\class Polyhedron} \\
\hline
\hline
\param \_origin & single integer or real value, or {\class Point} & classes {\class Rectangle}, {\class Square}, {\class Cuboid}, {\class Cube}, {\class Trunk}, {\class Cylinder}, {\class Prism} \\
\hline
\end{tabular}

\begin{tabular}{|p{3cm}|p{7cm}|p{6cm}|}
\hline
key & authorized types & concerned classes \\
\hline
\hline
\param \_radius & single unsigned  integer or real positive value & classes {\class Disk}, {\class Ball}, {\class RevCylinder}, {\class RevCone} \\
\hline
\param \_radius1 & single unsigned  integer or real positive value & class {\class RevTrunk} \\
\hline
\param \_radius2 & single unsigned  integer or real positive value & class {\class RevTrunk} \\
\hline
\hline
\param \_scale & single unsigned  integer or real positive value & class {\class Trunk} \\
\hline
\param \_side\_names & single string or std::vector of strings & every class but {\class Polyhedron} \\
\hline
\hline
\param \_type & single unsigned integer value & classes {\class Ellipse}, {\class Disk}, {\class Ellipsoid}, {\class Ball}, {\class RevTrunk}, {\class RevCylinder}, {\class RevCone} \\
\hline
\hline
\param \_varnames & single string or std::vector of strings & every class \\
\hline
\param \_vertices & vector of {\class Point} & class {\class Polygon} \\
\hline
\param \_v1 & single integer or real value, or {\class Point} & every class, but {\class Polygon}, {\class Polyhedron}, {\class RevTrunk}, {\class RevCylinder}, {\class RevCone} \\
\hline
\param \_v2 & single integer or real value, or {\class Point} & every class, but {\class Polygon}, {\class Polyhedron}, {\class RevTrunk}, {\class RevCylinder}, {\class RevCone} \\
\hline
\param \_v3 & single integer or real value, or {\class Point} & classes {\class Triangle}, {\class Quadrangle}, {\class Tetrahedron}, {\class Hexahedron}, {\class Prism}, {\class Pyramid} \\
\hline
\param \_v4 & single integer or real value, or {\class Point} &  classes {\class Quadrangle}, {\class Parallelogram}, {\class Rectangle}, {\class Square}, {\class Tetrahedron}, {\class Hexahedron}, {\class Parallelepiped}, {\class Cuboid}, {\class Cube}, {\class Pyramid} \\
\hline
\param \_v5 & single integer or real value, or {\class Point} & classes {\class Hexahedron}, {\class Parallelepiped}, {\class Cuboid}, {\class Cube} \\
\hline
\param \_v6 & single integer or real value, or {\class Point} & class {\class Hexahedron} \\
\hline
\param \_v7 & single integer or real value, or {\class Point} & class {\class Hexahedron} \\
\hline
\param \_v8 & single integer or real value, or {\class Point} & class {\class Hexahedron} \\
\hline
\hline
\param \_xlength & single unsigned  integer or real positive value & classes {\class Rectangle}, {\class Ellipse}, {\class Cuboid}, {\class Ellipsoid} \\
\hline
\param \_xmin & single integer or real value & classes {\class Rectangle}, {\class Cuboid} \\
\hline
\param \_xmax & single integer or real value & classes {\class Rectangle}, {\class Cuboid} \\
\hline
\hline
\param \_ylength & single unsigned  integer or real positive value & classes {\class Rectangle}, {\class Ellipse}, {\class Cuboid}, {\class Ellipsoid}\\
\hline
\param \_ymin & single integer or real value & classes {\class Rectangle}, {\class Cuboid} \\
\hline
\param \_ymax & single integer or real value & classes {\class Rectangle}, {\class Cuboid} \\
\hline
\hline
\param \_zlength & single unsigned  integer or real positive value & class {\class Cuboid} \\
\hline
\param \_zmin & single integer or real value & class {\class Cuboid} \\
\hline
\param \_zmax & single integer or real value & class {\class Cuboid} \\
\hline
\end{tabular}

A constructor of a geometry will take several {\class Parameter} object and transfer the building work to the 3 main following routines:

\begin{lstlisting}
// main function to build a geometry
void build(const std::vector<Parameter>& ps);
// build the list of available keys
std::set<ParameterKey> getParamsKeys();
// deal with one key and do the appropriate work
void buildParam(const Parameter& gp);
// deal with unused keys having default values and do the appropriate work
void buildDefaultParam(ParameterKey key);
\end{lstlisting}

For some geometries, there are some additional routines called by {\cmd build}.

\subsubsection{The {\class Segment} class}

A segment is just a straight line between 2 points, with a number of nodes.

\begin{lstlisting}
class Segment : public Curve
{
  private:
    Point p1_, p2_;
    Number n_;
    std::vector<real_t> h_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-segment}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 5 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p1\_, p2\_ & ({\param \_v1}, {\param \_v2}) & no & no \\
n\_ & {\param \_nnodes} & yes & 2 \\
 & or ({\param \_xmin}, {\param \_xmax}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning segments :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class EllArc} class}

To define an elliptic arc, you need 4 points : the center of the ellipse, a point on the main axis (apogee) and the bounds of the arc. When omitted, the apogee point is defined as the first bound of the arc. An elliptic arc must be smalller than a half-ellipse, to be defined correctly. This is a \gmsh restriction.

\begin{lstlisting}
class EllArc : public Curve
{
  protected:
    Point c_, a_, p1_, p2_;
    Number n_;
    std::vector<real_t> h_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-ellipsearc}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
c\_, a\_, p1\_, p2\_ & ({\param \_center}, {\param \_apogee}, {\param \_v1}, {\param \_v2}) & no & no \\
 & or ({\param \_center}, {\param \_v1}, {\param \_v2}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning elliptic arcs :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class CircArc} class}

To define a circular arc, you need 3 points : the center of the circle and the bounds of the arc. A circular arc must be smalller than a half-circle, to be defined correctly. This is a \gmsh restriction.

\begin{lstlisting}
class CircArc : public Curve
{
  protected:
    Point c_, p1_, p2_;
    number_t n_;
    std::vector<real_t> h_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-circlearc}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 6 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
c\_, p1\_, p2\_ & {\param \_center}, {\param \_v1} and {\param \_v2} & no & no \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning circular arcs :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Polygon} class}

To define a polygon, you give the ordered list of vertices.

\begin{lstlisting}
class Polygon : public Surface
{
  protected:
    std::vector<Point> p_;
    std::vector<real_t> h_;
    std::vector<number_t> n_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-polygon}
\end{center}
\end{figure}

It offers constructors, taking from 1 to 4 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_vertices} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning polygon :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Triangle} class}

To define a triangle, you give the 3 vertices.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-triangle}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 6 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2} and {\param \_v3} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning triangles :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Quadrangle} class}

To define a quadrangle, you give the 4 vertices.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-quadrangle}
\end{center}
\end{figure}

It offers constructors, taking from 4 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2}, {\param \_v3} and {\param \_v4} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning quadrangles :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Parallelogram} class}

To define a parallelogram, you give 3 vertices. $p_3$ is indeed unnecessary. It can be calculated from the 3 other vertices.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-parallelogram}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 6 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2} and {\param \_v4} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning parallelograms :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Rectangle} class}

To define a rectangle, you give 3 vertices, as for {\class Parallelogram}. You can also give the center (or the origin) and the lengths, or you can gives bounds. To store temporarily these values, the {\class Rectangle} class has internal attributes.

\begin{lstlisting}
class Rectangle : public Parallelogram
{
  protected:
    Point center_, origin_;
    bool isCenter_, isOrigin_;
    real_t xlength_, ylength_;
  private:
    real_t xmin_, xmax_, ymin_, ymax_;
    bool isBounds_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-rectangle}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v4}) & no & no \\
 & or ({\param \_center}, {\param \_xlength}, {\param \_ylength}) & & \\
 & or ({\param \_origin}, {\param \_xlength}, {\param \_ylength}) & & \\
 & or ({\param \_xmin}, {\param \_xmax}, {\param \_ymin}, {\param \_ymax}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning  rectangles :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Square} class}

To define a square, you give 3 vertices. You can also give the center (or the origin) and the length.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-square}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 6 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v4}) & no & no \\
 & or ({\param \_center}, {\param \_xlength}, {\param \_ylength}) & & \\
 & or ({\param \_origin}, {\param \_xlength}, {\param \_ylength}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning squares :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Ellipse} class}

To define an elliptic surface, you have to define a center and 2 apogees ($c$, $p1$ and $p2$ in the following figure):

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-ellipse}
\end{center}
\end{figure}

You can also define an ellipse from its center and the axis lengths, when axes are x-axis and y-axis.
The main attributes are center\_, p1\_, p2\_, p3\_, p4\_, those that will be used in meshing.

\begin{lstlisting}
class Ellipse : public Surface
{
  protected:
    Point center_, p1_, p2_, p3_, p4_;
    real_t xlength_, ylength_;
    bool isAxis_;
    number_t n1_, n2_, n3_, n4_;
    std::vector<real_t> h_;
    real_t thetamin_;
    real_t thetamax_;
    dimen_t type_;
\end{lstlisting}

It offers constructors, taking from 3 to 9 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
center\_, p1\_, p2\_, p3\_, p4\_ & ({\param \_center}, {\param \_v1} and {\param \_v2}) & no & no \\
 & or ({\param \_center}, {\param \_xlength}, {\param \_ylength}) & & \\
n1\_, n2\_, n3\_, n4\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
thetamin\_ & {\param \_angle1} & yes & 0 \\
thetamax\_ & {\param \_angle2} & yes & 360 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning elliptic surfaces and disks :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Disk} class}

To define a disk, you have to do the same way as {\class Ellipse}.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-disk}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 9 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
center\_, p1\_, p2\_, p3\_, p4\_ & ({\param \_center}, {\param \_v1} and {\param \_v2}) & no & no \\
 & or ({\param \_center}, {\param \_radius}) & & \\
n1\_, n2\_, n3\_, n4\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
thetamin\_ & {\param \_angle1} & yes & 0 \\
thetamax\_ & {\param \_angle2} & yes & 360 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning elliptic surfaces and disks :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Polyhedron} class}

A polyhedron is defined bi its polygonal faces.

\begin{lstlisting}
class Polyhedron : public Volume
{
  private:
    std::vector<Polygon*> faces_;
  protected:
    std::vector<Point> p_;
    std::vector<number_t> n_;
    std::vector<real_t> h_;
\end{lstlisting}

p\_, n\_ and h\_ are defined here but used in child classes.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-polyhedron}
\end{center}
\end{figure}

It offers constructors, taking from 1 to 2 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
faces\_ & {\param \_faces} & no & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning hexahedron, parallelepipeds and cubes :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Tetrahedron} class}

To define a tetrahedron, you just have to give the 4 vertices.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-tetrahedron}
\end{center}
\end{figure}

It offers constructors, taking from 4 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2}, {\param \_v3} and {\param \_v4} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning tetrahedron :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Hexahedron} class}

To define a hexahedron, you just have to give the 8 vertices.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-hexahedron}
\end{center}
\end{figure}

It offers constructors, taking from 8 to 11 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2}, {\param \_v3}, {\param \_v4}, {\param \_v5}, {\param \_v6}, {\param \_v7} and {\param \_v8} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning hexahedra  :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Parallelepiped} class}

To define a parallelepiped, you just have to give 4 vertices ($p_1$, $p_2$, $p_4$ and $p_5$ in the following figure):

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-parallelepiped}
\end{center}
\end{figure}

It offers constructors, taking from 4 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & {\param \_v1}, {\param \_v2}, {\param \_v4} and {\param \_v5} & no & no\\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning parallelepipeds :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Cuboid} class}

To define a cuboid, you just have to give 4 vertices, as for {\class Parallelepiped}. And as for {\class Rectangle}, you can define it by its center or its origin and its lengths, or define it by its bounds

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-cuboid}
\end{center}
\end{figure}

It offers constructors, taking from 4 to 9 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v4}, {\param \_v5}) & no & no \\
 & or ({\param \_center}, {\param \_xlength}, {\param \_ylength}, {\param \_zlength}) & & \\
 & or ({\param \_origin}, {\param \_xlength}, {\param \_ylength}, {\param \_zlength}) & & \\
 & or ({\param \_xmin}, {\param \_xmax}, {\param \_ymin}, {\param \_ymax}, {\param \_zmin}, {\param \_zmax}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning cuboids :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Cube} class}

To define a cube, you just have to give 4 vertices. You can also give the center or the origin and the length.

\begin{lstlisting}
class Cube : public Cuboid
{
  private:
    dimen_t nboctants_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-cube}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v4}, {\param \_v5}) & no & no \\
 & or ({\param \_center}, {\param \_length}) & & \\
 & or ({\param \_origin}, {\param \_length}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nboctants\_ & {\param \_nboctants} & yes & 8 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning cubes :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Ellipsoid} class}

To define an ellipsoid, you do the same way as for an ellipse, namely defining a center and 3 apogees ($c$, $p1$, $p2$ and $p_6$ in the following figure):

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-ellipsoid}
\end{center}
\end{figure}

\begin{lstlisting}
class Ellipsoid : public Volume
{
  protected:
    Point center_, p1_, p2_, p3_, p4_, p5_, p6_;
    real_t xlength_, ylength_, zlength_;
    bool isAxis_;

    number_t n1_, n2_, n3_, n4_, n5_, n6_, n7_, n8_, n9_, n10_, n11_, n12_;
    std::vector<real_t> h_;

    dimen_t nboctants_;
    dimen_t type_;
\end{lstlisting}

It offers constructors, taking from 4 to 9 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center}, {\param \_v1}, {\param \_v2}, {\param \_v6}) & no & no \\
 & or ({\param \_center}, {\param \_xlength}, {\param \_ylength}, {\param \_zlength}) & & \\
 & or ({\param \_origin}, {\param \_xlength}, {\param \_ylength}, {\param \_zlength}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nboctants\_ & {\param \_nboctants} & yes & 8 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning ellipsoids :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Ball} class}

To define a ball, you do the same way as for an ellipsoid.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-ball}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 9 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center}, {\param \_v1}, {\param \_v2}, {\param \_v6}) & no & no \\
 & or ({\param \_center}, {\param \_length}) & & \\
 & or ({\param \_origin}, {\param \_length}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nboctants\_ & {\param \_nboctants} & yes & 8 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning balls :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Trunk} class}

A trunk is a generalized truncated cone. To define a trunk, you need to give a surface, namely a polygonal surface or a elliptical surface. To define the other surface, you just need to give a point of this surface ($origin$), and the scale factor according to the first surface.

For a trunk with polygonal basis, $origin$ is the equivalent of the first vertex of the surface you give, as you can see on the following figure of a trunk with triangular basis. The triangle being defined by its vertices $p_1$, $p_2$ and $p_3$, $origin$ is the equivalent of $p_1$:

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-trunk-triangle}
\end{center}
\end{figure}

For a trunk with elliptical basis, $origin$ is the center of the second basis, as you can see on the following figure of a trunk with elliptical basis.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-trunk-ellipse}
\end{center}
\end{figure}

\begin{lstlisting}
class Trunk : public Volume
{
  protected:
    Surface * basis_;
    real_t scale_;
    std::vector<Point> p_;
    std::vector<number_t> n_;
    std::vector<real_t> h_;
    Point origin_, center1_, p1_, p2_;
    bool isElliptical_, isN_;
\end{lstlisting}

It offers constructors, taking from 3 to 8 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center1}, {\param \_v1}, {\param \_v2}, {\param \_center2}, {\param \_scale}) & no & no \\
 & or ({\param \_basis}, {\param \_origin}, {\param \_scale}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning trunks :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Cylinder} class}

A cylinder is a truncated cone whose apex is at infinite distance. So it is the geometry defined by the extrusion of a surface by translation.

\begin{lstlisting}
class Cylinder : public Trunk
{
  protected:
    //! direction vector
    Point dir_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-cylinder}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center1}, {\param \_v1}, {\param \_v2}, {\param \_center2}) & no & no \\
 & or ({\param \_basis}, {\param \_direction}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning cylinders :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Prism} class}

A prism is by definition a cylinder whose basis is a polygonal surface. Often a prism refers to a cylinder with triangular basis (as the finite element cell).

\begin{lstlisting}
class Prism : public Cylinder
{
  private:
    bool isTriangular_;
    Point p3_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-prism}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v3}, {\param \_direction}) & no & no \\
 & or ({\param \_basis}, {\param \_direction}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning prisms :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Cone} class}

A cone is defined by a surface and an apex. As for trunks and cylinders, you can also define directly a cone with elliptical basis.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-cone}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 7 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center1}, {\param \_v1}, {\param \_v2}, {\param \_apex}) & no & no \\
 & or ({\param \_basis}, {\param \_apex}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning cones :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class Pyramid} class}

A pyramid is a cone with a polygonal basis. Often a pyramid refers to a cone with quadrangular basis (as the finite element cell).

\begin{lstlisting}
class Pyramid : public Cone
{
  private:
    bool isQuadrangular_;
    Point p3_, p4_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-pyramid}
\end{center}
\end{figure}

It offers constructors, taking from 2 to 8 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_v1}, {\param \_v2}, {\param \_v3}, {\param \_v4}, {\param \_apex}) & no & no \\
 & or ({\param \_basis}, {\param \_apex}) & & \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning pyramids :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class RevTrunk} class}

A revolution trunk is a right trunk with circular basis. {\class RevTrunk} offers you more geometry abilities. Indeed, you can decide to add extensions at ends of  the revolution trunk. Extensions can be : none, flat, ellipsoid, or cone.


\begin{lstlisting}
class RevTrunk : public Trunk
{
  protected:
    real_t radius1_, radius2_;
    number_t nbSubDomains_;
    GeometricEndShape endShape1_;
    real_t distance1_;
    GeometricEndShape endShape2_;
    real_t distance2_;
    dimen_t type_;
\end{lstlisting}

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-revtrunk}
\end{center}
\end{figure}

It offers constructors, taking from 4 to 13 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center1}, {\param \_center2}, {\param \_radius1}, {\param \_radius2}) & no & no \\
endShape1\_ & {\param \_end1\_shape} &  yes & \_gesflat\\
endShape2\_ & {\param \_end2\_shape} & yes & \_gesFlat \\
distance1\_ & {\param \_end1\_distance} &  yes & 0. \\
distance2\_ & {\param \_end2\_distance} & yes & 0. \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nbSubDomains\_ & {\param \_nbsubdomains} & yes & 1 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning revolution trunks :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class RevCylinder} class}

A revolution cylinder is a revolution trunk where both radiuses are equal. So, we need centers of both bases, and the radius. As {\class RevTrunk}, {\class RevCylinder} offers you the ability to add extensions at ends of  the revolution cylinder.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-revcylinder}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 12 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center1}, {\param \_center2}, {\param \_radius}) & no & no \\
endShape1\_ & {\param \_end1\_shape} &  yes & \_gesflat\\
endShape2\_ & {\param \_end2\_shape} & yes & \_gesFlat \\
distance1\_ & {\param \_end1\_distance} &  yes & 0. \\
distance2\_ & {\param \_end2\_distance} & yes & 0. \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nbSubDomains\_ & {\param \_nbsubdomains} & yes & 1 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning revolution cylinders :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class RevCone} class}

A revolution cone is a revolution trunk where second radius is equal to 0. As {\class RevTrunk},  {\class RevCone} offers you more the ability to add an extension to the basis of a revolution cone.

\begin{figure}[H]
\begin{center}
\inputTikZ{geo-revcone}
\end{center}
\end{figure}

It offers constructors, taking from 3 to 10 {\class Parameter}. Authorized keys and what they do are:

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
attribute & key to use to define it & optional & default value \\
\hline
\hline
p\_ & ({\param \_center}, {\param \_radius}, {\param \_apex}) & no & no \\
endShape1\_ & {\param \_end\_shape} &  yes & \_gesflat\\
distance1\_ & {\param \_end\_distance} &  yes & 0. \\
n\_ & {\param \_nnodes} & yes & 2 \\
h\_ & {\param \_hsteps} & yes & no \\
domName\_ & {\param \_domain\_name} & yes & "" \\
sideNames\_ & {\param \_side\_names} & yes & "" \\
nbSubDomains\_ & {\param \_nbsubdomains} & yes & 1 \\
type\_ & {\param \_type} & yes & 1 \\
\hline
\end{tabular}
\end{center}

It also offers :

\begin{itemize}
\item some accessors
\item implementation of inherited virtual functions concerning revolution cones :
\begin{lstlisting}
virtual void computeMB();
virtual std::vector<const Point*> boundNodes() const;
virtual std::vector<Point*> nodes();
virtual std::vector<const Point*> nodes() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > curves() const;
virtual std::vector<std::pair<ShapeType,std::vector<const Point*> > > surfs() const;
\end{lstlisting}
\end{itemize}

\subsubsection{The {\class SetOfElems} class}