src/MEDMEM/MEDMEM_Mesh.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2011  CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

#ifndef MESH_HXX
#define MESH_HXX

#include <MEDMEM.hxx>

#include <string>
#include <vector>
#include <list>
#include <map>

#include "MEDMEM_GMesh.hxx"
#include "MEDMEM_Utilities.hxx"
#include "MEDMEM_STRING.hxx"
#include "MEDMEM_Exception.hxx"
#include "MEDMEM_define.hxx"
#include "MEDMEM_Coordinate.hxx"
#include "MEDMEM_Connectivity.hxx"
#include "MEDMEM_GenDriver.hxx"
#include "MEDMEM_RCBase.hxx"
#include "MEDMEM_FieldForward.hxx"

namespace MEDMEM {

class CELLMODEL;
class FAMILY;
class GROUP;
class SUPPORT;
class MESH;

MEDMEM_EXPORT ostream & operator<<(ostream &os, const MESH &my);

class MEDMEM_EXPORT MESH : public GMESH
{
  //-----------------------//
  //   Attributes
  //-----------------------//

protected :

  int   _numberOfNodes;
  mutable COORDINATE *   _coordinate;
  mutable CONNECTIVITY * _connectivity;


  int _arePresentOptionnalNodesNumbers;
  map<int,int> _optionnalToCanonicNodesNumbers;

  //-----------------------//
  //   Methods
  //-----------------------//

 public :

  // Add your personnal driver line (step 2)
  friend class MED_MESH_RDONLY_DRIVER;
  friend class MED_MESH_WRONLY_DRIVER;

  friend class MED_MED_RDONLY_DRIVER21;
  friend class MED_MED_WRONLY_DRIVER21;
  friend class MED_MED_RDWR_DRIVER21;
  friend class MED_MED_RDONLY_DRIVER22;
  friend class MED_MED_WRONLY_DRIVER22;
  friend class MED_MED_RDWR_DRIVER22;

  friend class GIBI_MESH_RDONLY_DRIVER;
  friend class GIBI_MESH_WRONLY_DRIVER;
  friend class GIBI_MESH_RDWR_DRIVER;

  friend class PORFLOW_MESH_RDONLY_DRIVER;
  friend class PORFLOW_MESH_WRONLY_DRIVER;
  friend class PORFLOW_MESH_RDWR_DRIVER;

  friend class VTK_MESH_DRIVER;

  friend class ENSIGHT_MESH_RDONLY_DRIVER;

 public:
  MESH();
  MESH(MESH &m);
  virtual ~MESH();
  MESH( driverTypes driverType, const string & fileName="",
        const string & meshName="") throw (MEDEXCEPTION);
 public:
  void init();
  MESH & operator=(const MESH &m);
  virtual bool operator==(const MESH& other) const;
  virtual bool deepCompare(const GMESH& other) const;
  virtual bool isEmpty() const;

  friend ostream & operator<<(ostream &os, const MESH &my);
  virtual void printMySelf(ostream &os) const;

  virtual int         getMeshDimension() const;
  virtual bool        getIsAGrid() const;
  virtual const MESH* convertInMESH() const;

  inline int                        getNumberOfNodes() const;
  virtual inline const COORDINATE * getCoordinateptr() const;
  inline string                     getCoordinatesSystem() const;
  virtual inline const double *     getCoordinates(MED_EN::medModeSwitch Mode) const;
  virtual inline const double       getCoordinate(int Number,int Axis) const;
  inline const string *             getCoordinatesNames() const;
  inline const string *             getCoordinatesUnits() const;

  virtual inline int getNumberOfTypes(MED_EN::medEntityMesh Entity) const;
  virtual inline const MED_EN::medGeometryElement * getTypes(MED_EN::medEntityMesh Entity) const;
  virtual inline const CELLMODEL * getCellsTypes(MED_EN::medEntityMesh Entity) const;
  virtual inline string * getCellTypeNames(MED_EN::medEntityMesh Entity) const;
  virtual inline const int * getGlobalNumberingIndex(MED_EN::medEntityMesh Entity) const;
  virtual inline int getNumberOfElements(MED_EN::medEntityMesh Entity,
                                         MED_EN::medGeometryElement Type) const;
  virtual inline bool existConnectivity(MED_EN::medConnectivity ConnectivityType,
                                        MED_EN::medEntityMesh Entity) const;

  virtual inline MED_EN::medGeometryElement getElementType(MED_EN::medEntityMesh Entity,
                                                           int Number) const;
  virtual inline void calculateConnectivity(MED_EN::medConnectivity ConnectivityType,
                                            MED_EN::medEntityMesh Entity) const ;
  virtual inline int getConnectivityLength(MED_EN::medConnectivity ConnectivityType,
                                           MED_EN::medEntityMesh Entity,
                                           MED_EN::medGeometryElement Type) const;
  virtual inline const int * getConnectivity(MED_EN::medConnectivity ConnectivityType,
                                             MED_EN::medEntityMesh Entity,
                                             MED_EN::medGeometryElement Type) const;
  virtual inline const int * getConnectivityIndex(MED_EN::medConnectivity ConnectivityType,
                                                  MED_EN::medEntityMesh Entity) const;

  virtual int                 getElementNumber(MED_EN::medConnectivity ConnectivityType,
                                               MED_EN::medEntityMesh Entity,
                                               MED_EN::medGeometryElement Type,
                                               int * connectivity) const;
  virtual inline int getReverseConnectivityLength(MED_EN::medConnectivity ConnectivityType,
                                                  MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) const;
  virtual inline const int * getReverseConnectivity(MED_EN::medConnectivity ConnectivityType,
                                                    MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) const;
  virtual inline int getReverseConnectivityIndexLength(MED_EN::medConnectivity ConnectivityType,
                                                         MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) const;
  virtual inline const int * getReverseConnectivityIndex(MED_EN::medConnectivity ConnectivityType,
                                                         MED_EN::medEntityMesh Entity=MED_EN::MED_CELL) const;

  virtual inline const CONNECTIVITY*   getConnectivityptr() const;
  inline void setConnectivityptr(CONNECTIVITY*);
  virtual SUPPORT *                    getBoundaryElements(MED_EN::medEntityMesh Entity) const
                                                throw (MEDEXCEPTION);
  virtual SUPPORT *                    getSkin(const SUPPORT * Support3D)
                                                throw (MEDEXCEPTION);

  //  Node DonneBarycentre(const Cell &m) const;
  virtual FIELD<double>* getVolume (const SUPPORT * Support, bool isAbs = true) const
                                throw (MEDEXCEPTION);
                                // Support must be on 3D elements
  virtual FIELD<double>* getArea (const SUPPORT * Support) const
                                throw (MEDEXCEPTION);
                                // Support must be on 2D elements
  virtual FIELD<double>* getLength (const SUPPORT * Support) const
                                throw (MEDEXCEPTION);
                                // Support must be on 1D elements
  virtual FIELD<double>* getNormal (const SUPPORT * Support) const
                                throw (MEDEXCEPTION);
                                // Support must be on 2D elements
  virtual FIELD<double>* getBarycenter (const SUPPORT * Support) const
                                throw (MEDEXCEPTION);
  //  FIELD<int>* getNeighbourhood(SUPPORT * Support) const
  //                            throw (MEDEXCEPTION); // Il faut preciser !

  SUPPORT *buildSupportOnNodeFromElementList(const list<int>& listOfElt, MED_EN::medEntityMesh entity) const throw (MEDEXCEPTION);
  void fillSupportOnNodeFromElementList(const list<int>& listOfElt, SUPPORT *supportToFill) const throw (MEDEXCEPTION);
  int getElementContainingPoint(const double *coord);
  vector< vector<double> > getBoundingBox() const;
  void convertToPoly();
};

// ---------------------------------------
//              Methodes Inline
// ---------------------------------------

inline const CONNECTIVITY* MESH::getConnectivityptr() const
{
//   checkGridFillConnectivity();
  return _connectivity;
}

inline void MESH::setConnectivityptr(CONNECTIVITY* conn)
{
  if(_connectivity)
    delete _connectivity;
  _connectivity=conn;
}

inline int MESH::getNumberOfNodes() const
{
  return _numberOfNodes;
}

inline const COORDINATE * MESH::getCoordinateptr() const
{
//   checkGridFillCoords();
  return _coordinate;
}

inline string MESH::getCoordinatesSystem() const
{
  return _coordinate->getCoordinatesSystem();
}

inline const double * MESH::getCoordinates(MED_EN::medModeSwitch Mode) const
{
//   checkGridFillCoords();
  return _coordinate->getCoordinates(Mode);
}

inline const double MESH::getCoordinate(int number, int axis) const
{
//   checkGridFillCoords();
  return _coordinate->getCoordinate(number,axis);
}

inline const string * MESH::getCoordinatesNames() const
{
  return _coordinate->getCoordinatesNames();
}

inline const string * MESH::getCoordinatesUnits() const
{
  return _coordinate->getCoordinatesUnits();
}
//  int * MESH::getNodesNumbers() const
//  {
//    return nodesNumbers;
//  }

inline int MESH::getNumberOfTypes(MED_EN::medEntityMesh entity) const
{
  MESSAGE_MED("MESH::getNumberOfTypes(medEntityMesh entity) : "<<entity);
  if (entity == MED_EN::MED_NODE)
    return 1;
//   checkGridFillConnectivity();
  if (_connectivity != NULL)
    return _connectivity->getNumberOfTypes(entity);
  throw MEDEXCEPTION(LOCALIZED("MESH::getNumberOfTypes( medEntityMesh ) : Connectivity not defined !"));
}

inline const MED_EN::medGeometryElement * MESH::getTypes(MED_EN::medEntityMesh entity) const
{
  if (entity == MED_EN::MED_NODE)
    throw MEDEXCEPTION(LOCALIZED("MESH::getTypes( medEntityMesh ) : No medGeometryElement with MED_NODE entity !"));
  // return un tableau de taille 1 contenant MED_NONE, comme les supports pour etre coherent avec getNumberOfTypes ???? PG

//   checkGridFillConnectivity();
  if (_connectivity != NULL)
    return _connectivity->getGeometricTypes(entity);
  throw MEDEXCEPTION(LOCALIZED("MESH::getTypes( medEntityMesh ) : Connectivity not defined !"));
}
inline const CELLMODEL * MESH::getCellsTypes(MED_EN::medEntityMesh Entity) const
{
  //  checkGridFillConnectivity();
  if (_connectivity != NULL)
    return _connectivity->getCellsTypes(Entity);
  throw MEDEXCEPTION(LOCALIZED("MESH::getCellsTypes( medEntityMesh ) : Connectivity not defined !"));
}

inline string * MESH::getCellTypeNames(MED_EN::medEntityMesh Entity) const
{
  //  checkGridFillConnectivity();
  if (_connectivity != NULL)
    return _connectivity->getCellTypeNames(Entity);
  throw MEDEXCEPTION(LOCALIZED("MESH::getCellTypesName( medEntityMesh ) : Connectivity not defined !"));
}
inline const int * MESH::getGlobalNumberingIndex(MED_EN::medEntityMesh entity) const
{
  //  checkGridFillConnectivity();
  if (_connectivity != NULL)
    return _connectivity->getGlobalNumberingIndex(entity);
  throw MEDEXCEPTION(LOCALIZED("MESH::getNumberOfTypes( medEntityMesh ) : Connectivity not defined !"));
}
inline int MESH::getNumberOfElements(MED_EN::medEntityMesh entity, MED_EN::medGeometryElement Type) const
{
  if (entity==MED_EN::MED_NODE)
    if ((Type==MED_EN::MED_NONE)|(Type==MED_EN::MED_ALL_ELEMENTS))
      return _numberOfNodes;
    else
      return 0;
  //throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"wrong medGeometryElement with MED_NODE"));
  else
    {
//       checkGridFillConnectivity();
      if (_connectivity != (CONNECTIVITY*)NULL)
        return _connectivity->getNumberOf(entity,Type);
      else
        return 0;
      //throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"connectivity not defined !"));
    }
}
inline bool MESH::existConnectivity(MED_EN::medConnectivity connectivityType, MED_EN::medEntityMesh entity) const
{
//   checkGridFillConnectivity();
  if (_connectivity==(CONNECTIVITY*)NULL)
    throw MEDEXCEPTION("MESH::existConnectivity(medConnectivity,medEntityMesh) : no connectivity defined !");
  return _connectivity->existConnectivity(connectivityType,entity);
}
inline MED_EN::medGeometryElement MESH::getElementType(MED_EN::medEntityMesh Entity,int Number) const
{
  //  checkGridFillConnectivity();
  if (_connectivity==(CONNECTIVITY*)NULL)
    throw MEDEXCEPTION("MESH::getElementType(medEntityMesh,int) : no connectivity defined !");
  return _connectivity->getElementType(Entity,Number);
}
inline void MESH::calculateConnectivity(MED_EN::medConnectivity ConnectivityType,MED_EN::medEntityMesh entity) const
{
  _connectivity->calculateConnectivity(ConnectivityType,entity);
}
inline int MESH::getConnectivityLength(MED_EN::medConnectivity ConnectivityType,MED_EN::medEntityMesh entity, MED_EN::medGeometryElement Type) const
{
  int nbOfElm = getNumberOfElements(entity,Type);
  int size;

  if (Type == MED_EN::MED_ALL_ELEMENTS)
    {
      size = getConnectivityIndex(ConnectivityType,entity)[nbOfElm]-1;
    }
  else
    {
      size = _connectivity->getConnectivityLength(ConnectivityType,entity,Type); // issue 19983
    }
  return size;
}

inline const int * MESH::getConnectivity(MED_EN::medConnectivity ConnectivityType,MED_EN::medEntityMesh entity, MED_EN::medGeometryElement Type) const
{
  return _connectivity->getConnectivity(ConnectivityType,entity,Type);
}
inline const int * MESH::getConnectivityIndex(MED_EN::medConnectivity    ConnectivityType,
                                              MED_EN::medEntityMesh      entity) const
{
  return _connectivity->getConnectivityIndex(ConnectivityType, entity);
}

inline int MESH::getReverseConnectivityLength(MED_EN::medConnectivity ConnectivityType,
                                              MED_EN::medEntityMesh   Entity) const
{
  int spaceDim = getSpaceDimension();
  int nb;

  if (ConnectivityType == MED_EN::MED_NODAL)
    {
      nb = getNumberOfNodes();
    }
  else
    {
      if (spaceDim == 2)
        nb = getNumberOfElements(MED_EN::MED_EDGE,
                                        MED_EN::MED_ALL_ELEMENTS);
      else if (spaceDim == 3)
        nb = getNumberOfElements(MED_EN::MED_FACE,
                                        MED_EN::MED_ALL_ELEMENTS);
    }
  return getReverseConnectivityIndex(ConnectivityType,Entity)[nb]-1;
}
inline const int * MESH::getReverseConnectivity(MED_EN::medConnectivity ConnectivityType,MED_EN::medEntityMesh Entity/*=MED_CELL*/) const
{
  //  checkGridFillConnectivity();
  if (NULL==_connectivity)
    throw MEDEXCEPTION("MESH::getReverseConnectivity : no connectivity defined in MESH !");

  return _connectivity->getReverseConnectivity(ConnectivityType,Entity);
}
inline int MESH::getReverseConnectivityIndexLength(MED_EN::medConnectivity ConnectivityType,
                                                         MED_EN::medEntityMesh Entity) const
{
  int spaceDim = getSpaceDimension();

  if (ConnectivityType == MED_EN::MED_NODAL)
    {
      return getNumberOfNodes()+1;
    }
  else
    {
      if (spaceDim == 2)
        return getNumberOfElements(MED_EN::MED_EDGE,MED_EN::MED_ALL_ELEMENTS)+1;
      else if (spaceDim == 3)
        return getNumberOfElements(MED_EN::MED_FACE,MED_EN::MED_ALL_ELEMENTS)+1;
      else
        throw MEDEXCEPTION("Invalid dimension");
    }
}
inline const int * MESH::getReverseConnectivityIndex(MED_EN::medConnectivity ConnectivityType,MED_EN::medEntityMesh Entity/*=MED_CELL*/) const
{
  //  checkGridFillConnectivity();
  if (NULL==_connectivity)
    throw MEDEXCEPTION("MESH::getReverseConnectivityIndex : no connectivity defined in MESH !");

  return _connectivity->getReverseConnectivityIndex(ConnectivityType,Entity);
}

}

#endif /* MESH_HXX */