src/MEDMEM/MEDMEM_Support.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
//

/*
  File Support.hxx
*/

#ifndef SUPPORT_HXX
#define SUPPORT_HXX

#include <MEDMEM.hxx>

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

#include "MEDMEM_Utilities.hxx"
#include "MEDMEM_STRING.hxx"
#include "MEDMEM_Exception.hxx"
#include "MEDMEM_define.hxx"
#include "MEDMEM_SkyLineArray.hxx"
#include "MEDMEM_RCBase.hxx"


namespace MEDMEM {

  class GMESH;
  class MESH;

class MEDMEM_EXPORT SUPPORT : public RCBASE
{
protected:
  std::string                   _name;

  mutable std::string                   _meshName;

  std::string                   _description;

  mutable const GMESH *            _mesh;

  MED_EN::medEntityMesh            _entity ;

  int                      _numberOfGeometricType;

  PointerOf<MED_EN::medGeometryElement>     _geometricType;

  bool                     _isOnAllElts;

  PointerOf<int>                    _numberOfElements;

  int                      _totalNumberOfElements;

  // the two following arrays are defined only if _isOnAllElts is false :

  mutable MEDSKYLINEARRAY * _number;

  mutable MEDSKYLINEARRAY * _number_fromfile;

  std::vector< std::string > _profilNames;
public:
  SUPPORT();
  //SUPPORT(GMESH* Mesh, std::string Name="", MED_EN::medEntityMesh Entity=MED_EN::MED_CELL);
  SUPPORT(const SUPPORT & m);
public:
  friend MEDMEM_EXPORT ostream & operator<<(ostream &os,const SUPPORT &my);

  SUPPORT& operator=(const SUPPORT &support);
  bool operator == (const SUPPORT &support) const;
  bool deepCompare(const SUPPORT &support) const;
  void update();

  inline void setName(const std::string& Name);
  inline void setDescription(const std::string& Description);
  void        setMesh(const GMESH *Mesh) const;
  void        setMeshName(const string & meshName);
  inline void setAll(bool All);
  void        setEntity(MED_EN::medEntityMesh Entity);
  void        setNumberOfGeometricType(int NumberOfGeometricType);
  void        setGeometricType(const MED_EN::medGeometryElement *GeometricType);
  void        setNumberOfElements(const int *NumberOfElements);
  void        setNumber(MEDSKYLINEARRAY * Number);
  void        setNumber(const int * index, const int* value, bool shallowCopy=false);

  inline const std::string&    getName() const;
  inline const std::string&    getDescription() const;
  virtual inline const GMESH * getMesh() const;
  std::string                  getMeshName() const;
  inline MED_EN::medEntityMesh getEntity() const;

  inline bool   isOnAllElements() const;
  inline int    getNumberOfTypes() const;
  inline const MED_EN::medGeometryElement* getTypes() const ;
  int           getNumberOfElements(MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
  const int *   getNumberOfElements() const throw (MEDEXCEPTION);
  virtual MEDSKYLINEARRAY *   getnumber() const throw (MEDEXCEPTION);
  virtual MEDSKYLINEARRAY *   getnumberFromFile() const throw (MEDEXCEPTION);
  virtual const int *         getNumber(MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
  virtual const int *         getNumberFromFile(MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
  virtual        const int *  getNumberIndex() const throw (MEDEXCEPTION);
  virtual int getValIndFromGlobalNumber(const int number) const throw (MEDEXCEPTION);

  void blending(const SUPPORT * mySupport) throw (MEDEXCEPTION) ;

  // Les numéros d'entités dans les profils doivent être croissant
  // pour respecter la norme MED
  void setpartial(const std::string& Description, int NumberOfGeometricType,
                  int TotalNumberOfEntity, const MED_EN::medGeometryElement *GeometricType,
                  const int *NumberOfEntity, const int *NumberValue);

  void setpartial(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION);


  void setpartial_fromfile(MEDSKYLINEARRAY * number, bool shallowCopy=false) throw (MEDEXCEPTION);
  
  // Si les noms de profils ne sont pas positionnés, les profils ne seront
  // pas écrits par MEDFICHIER.
  void   setProfilNames(const std::vector<std::string>& profilNames) throw (MEDEXCEPTION);
  //string getProfilName(const MED_EN::medGeometryElement GeometricType) const throw (MEDEXCEPTION);
  std::vector<std::string> getProfilNames() const throw (MEDEXCEPTION);

  void getBoundaryElements() throw (MEDEXCEPTION);
  void changeElementsNbs(MED_EN::medEntityMesh entity, const int *renumberingFromOldToNew);
  void intersecting(const SUPPORT * mySupport) throw (MEDEXCEPTION) ;
  bool belongsTo(const SUPPORT& other, bool deepCompare=false) const;
  SUPPORT *getComplement() const;
  SUPPORT *substract(const SUPPORT& other) const throw (MEDEXCEPTION) ;
  SUPPORT *getBoundaryElements(MED_EN::medEntityMesh Entity) const throw (MEDEXCEPTION);
  SUPPORT* buildSupportOnNode() const throw (MEDEXCEPTION);
  void fillFromNodeList(const std::list<int>& listOfNode) throw (MEDEXCEPTION);
  void fillFromElementList(const std::list<int>& listOfElt) throw (MEDEXCEPTION);
  void clearDataOnNumbers();
  MESH* makeMesh() const;
 protected:
  virtual ~SUPPORT();
 protected:
  static std::list<int> *sub(int start,int end,const int *idsToSuppress,int lgthIdsToSuppress);
  static std::list<int> *sub(const int *ids,int lgthIds,const int *idsToSuppress,int lgthIdsToSuppress);
};

// _____________________
// Methodes Inline
// _____________________

//--------------------------------------
inline void SUPPORT::setName(const std::string& Name)
//--------------------------------------
{
  _name=Name;
}

//--------------------------------------------------
inline void SUPPORT::setDescription(const std::string& Description)
//--------------------------------------------------
{
  _description=Description;
}

//------------------------------------------
inline void SUPPORT::setAll(bool All)
//------------------------------------------
{
  _isOnAllElts=All;
}
//------------------------------------
inline const std::string& SUPPORT::getName() const
//------------------------------------
{
  return _name;
}

//--------------------------------------------
inline const std::string& SUPPORT::getDescription() const
//--------------------------------------------
{
  return _description;
}

//------------------------------------
inline const GMESH * SUPPORT::getMesh() const
//------------------------------------
{
  return _mesh;
}

//------------------------------------------
inline bool SUPPORT::isOnAllElements() const
//------------------------------------------
{
  return _isOnAllElts;
}

//------------------------------------------
inline int SUPPORT::getNumberOfTypes() const
//------------------------------------------
{
  //    if ((_isOnAllElts)&(_entity != MED_NODE))
  //      return _mesh->getNumberOfTypes(_entity) ;
  //    else
  return _numberOfGeometricType ;
}

//---------------------------------------------
inline MED_EN::medEntityMesh SUPPORT::getEntity() const
//---------------------------------------------
{
  return _entity;
}

//---------------------------------------------------
inline const MED_EN::medGeometryElement * SUPPORT::getTypes() const
//---------------------------------------------------
{
  return _geometricType;
}

}//End namespace MEDMEM


#endif /* SUPPORT_HXX */