tui/SMESH/SMESHDS__Mesh_8hxx_source.html

// Copyright (C) 2007-2026  CEA, EDF, 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, or (at your option) any later version.

//

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

//


//  SMESH SMESHDS : management of mesh data and SMESH document

//  File   : SMESHDS_Mesh.hxx

//  Module : SMESH

//

#ifndef _SMESHDS_Mesh_HeaderFile

#define _SMESHDS_Mesh_HeaderFile


#include "SMESH_SMESHDS.hxx"


#include "SMDS_Mesh.hxx"

#include "SMESH_Utils.hxx"

#include "SMESH_RegularGrid.hxx"

#include "SMESHDS_SubMesh.hxx"


#include <Basics_OCCTVersion.hxx>


#include <TopTools_IndexedMapOfShape.hxx>

#include <TopoDS_Shape.hxx>


#include <map>


class TopoDS_Solid ;

class TopoDS_Shell ;

class TopoDS_Face  ;

class TopoDS_Vertex;

class TopoDS_Edge  ;


class SMESHDS_Script;

class SMESHDS_Hypothesis;

class SMDS_MeshNode     ;

class SMDS_MeshEdge     ;

class SMDS_MeshFace     ;

class SMDS_MeshVolume   ;

class SMDS_Mesh0DElement;

class SMDS_BallElement;


/*

 * Using of native hash_map isn't portable and don't work on WIN32 platform.

 * So this functionality implement on new NCollection_DataMap technology

 */

#include <NCollection_DataMap.hxx>

typedef std::list<const SMESHDS_Hypothesis*>                          THypList;


struct SMESHDS_Hasher

{

#if OCC_VERSION_LARGE < 0x07080000

  static inline Standard_Boolean IsEqual(const TopoDS_Shape& S1,

                                         const TopoDS_Shape& S2)

  {

    return S1.IsSame(S2);

  }

  static inline Standard_Integer HashCode(const TopoDS_Shape& S,

                                          const Standard_Integer Upper)

  {

    return ::HashCode( S, Upper);

  }

#else

  bool operator()(const TopoDS_Shape& S1, const TopoDS_Shape& S2) const

  {

    // for the purpose of ShapeToHypothesis map we don't consider shapes orientation

    return S1.IsSame(S2);

  }

  size_t operator()(const TopoDS_Shape& S) const

  {

    return std::hash<TopoDS_Shape>{}(S);

  }

#endif

};


typedef NCollection_DataMap< TopoDS_Shape, THypList, SMESHDS_Hasher > ShapeToHypothesis;


class SMESHDS_GroupBase;

class DownIdType;


class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh

{

 public:

  SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);

  bool IsEmbeddedMode();

  void SetPersistentId(int id);

  int GetPersistentId() const;


  void ShapeToMesh(const TopoDS_Shape & S);

  TopoDS_Shape ShapeToMesh() const;

  bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);

  bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);


  virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);

  virtual SMDS_MeshNode* AddNode(double x, double y, double z);


  virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType nodeID, smIdType ID);

  virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, smIdType ID);

  virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);


  virtual SMDS_BallElement* AddBallWithID(smIdType n,                   double diameter, smIdType ID);

  virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);

  virtual SMDS_BallElement* AddBall      (const SMDS_MeshNode * n, double diameter);


  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);

  virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       smIdType ID);

  virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2);


  // 2d order edge with 3 nodes: n12 - node between n1 and n2

  virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);

  virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n12,

                                       smIdType ID);

  virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n12);

  // tria 3

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3);

  // quad 4

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4);


  // 2d order triangle of 6 nodes

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,

                                       smIdType n12,smIdType n23,smIdType n31, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n31,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n31);


  // biquadratic triangle of 7 nodes

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,

                                       smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n31,

                                       const SMDS_MeshNode * nCenter,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n31,

                                 const SMDS_MeshNode * nCenter);


  // 2d order quadrangle

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n34,

                                       const SMDS_MeshNode * n41,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n34,

                                 const SMDS_MeshNode * n41);


  // biquadratic quadrangle of 9 nodes

  virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                       smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);

  virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                       const SMDS_MeshNode * n2,

                                       const SMDS_MeshNode * n3,

                                       const SMDS_MeshNode * n4,

                                       const SMDS_MeshNode * n12,

                                       const SMDS_MeshNode * n23,

                                       const SMDS_MeshNode * n34,

                                       const SMDS_MeshNode * n41,

                                       const SMDS_MeshNode * nCenter,

                                       smIdType ID);

  virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                 const SMDS_MeshNode * n2,

                                 const SMDS_MeshNode * n3,

                                 const SMDS_MeshNode * n4,

                                 const SMDS_MeshNode * n12,

                                 const SMDS_MeshNode * n23,

                                 const SMDS_MeshNode * n34,

                                 const SMDS_MeshNode * n41,

                                 const SMDS_MeshNode * nCenter);

  // tetra 4

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4);

  // pyra 5

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5);

  // penta 6

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6);

  // hexa 8

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8);

  // hexagonal prism of 12 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n9,

                                           const SMDS_MeshNode * n10,

                                           const SMDS_MeshNode * n11,

                                           const SMDS_MeshNode * n12,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n9,

                                     const SMDS_MeshNode * n10,

                                     const SMDS_MeshNode * n11,

                                     const SMDS_MeshNode * n12);


  // 2d order tetrahedron of 10 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n14,smIdType n24,smIdType n34, smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n24,

                                           const SMDS_MeshNode * n34,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n24,

                                     const SMDS_MeshNode * n34);


  // 2d order pyramid of 13 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n15,smIdType n25,smIdType n35,smIdType n45,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n35,

                                           const SMDS_MeshNode * n45,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n35,

                                     const SMDS_MeshNode * n45);


  // 2d order Pentahedron with 15 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,

                                           smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n45,smIdType n56,smIdType n64,

                                           smIdType n14,smIdType n25,smIdType n36,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n45,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n64,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n36,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n45,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n64,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n36);


  // 2d order Pentahedron with 18 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,

                                           smIdType n4, smIdType n5, smIdType n6,

                                           smIdType n12,smIdType n23,smIdType n31,

                                           smIdType n45,smIdType n56,smIdType n64,

                                           smIdType n14,smIdType n25,smIdType n36,

                                           smIdType n1245, smIdType n2356, smIdType n1346,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n31,

                                           const SMDS_MeshNode * n45,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n64,

                                           const SMDS_MeshNode * n14,

                                           const SMDS_MeshNode * n25,

                                           const SMDS_MeshNode * n36,

                                           const SMDS_MeshNode * n1245,

                                           const SMDS_MeshNode * n2356,

                                           const SMDS_MeshNode * n1346,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n31,

                                     const SMDS_MeshNode * n45,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n64,

                                     const SMDS_MeshNode * n14,

                                     const SMDS_MeshNode * n25,

                                     const SMDS_MeshNode * n36,

                                     const SMDS_MeshNode * n1245,

                                     const SMDS_MeshNode * n2356,

                                     const SMDS_MeshNode * n1346);


  // 2d order Hexahedrons with 20 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,

                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n67,

                                           const SMDS_MeshNode * n78,

                                           const SMDS_MeshNode * n85,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n26,

                                           const SMDS_MeshNode * n37,

                                           const SMDS_MeshNode * n48,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n67,

                                     const SMDS_MeshNode * n78,

                                     const SMDS_MeshNode * n85,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n26,

                                     const SMDS_MeshNode * n37,

                                     const SMDS_MeshNode * n48);


  // 2d order Hexahedrons with 27 nodes

  virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,

                                           smIdType n5, smIdType n6, smIdType n7, smIdType n8,

                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,

                                           smIdType n56,smIdType n67,smIdType n78,smIdType n85,

                                           smIdType n15,smIdType n26,smIdType n37,smIdType n48,

                                           smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,

                                           smIdType n1458,smIdType n5678,smIdType nCenter,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                           const SMDS_MeshNode * n2,

                                           const SMDS_MeshNode * n3,

                                           const SMDS_MeshNode * n4,

                                           const SMDS_MeshNode * n5,

                                           const SMDS_MeshNode * n6,

                                           const SMDS_MeshNode * n7,

                                           const SMDS_MeshNode * n8,

                                           const SMDS_MeshNode * n12,

                                           const SMDS_MeshNode * n23,

                                           const SMDS_MeshNode * n34,

                                           const SMDS_MeshNode * n41,

                                           const SMDS_MeshNode * n56,

                                           const SMDS_MeshNode * n67,

                                           const SMDS_MeshNode * n78,

                                           const SMDS_MeshNode * n85,

                                           const SMDS_MeshNode * n15,

                                           const SMDS_MeshNode * n26,

                                           const SMDS_MeshNode * n37,

                                           const SMDS_MeshNode * n48,

                                           const SMDS_MeshNode * n1234,

                                           const SMDS_MeshNode * n1256,

                                           const SMDS_MeshNode * n2367,

                                           const SMDS_MeshNode * n3478,

                                           const SMDS_MeshNode * n1458,

                                           const SMDS_MeshNode * n5678,

                                           const SMDS_MeshNode * nCenter,

                                           smIdType ID);

  virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                     const SMDS_MeshNode * n2,

                                     const SMDS_MeshNode * n3,

                                     const SMDS_MeshNode * n4,

                                     const SMDS_MeshNode * n5,

                                     const SMDS_MeshNode * n6,

                                     const SMDS_MeshNode * n7,

                                     const SMDS_MeshNode * n8,

                                     const SMDS_MeshNode * n12,

                                     const SMDS_MeshNode * n23,

                                     const SMDS_MeshNode * n34,

                                     const SMDS_MeshNode * n41,

                                     const SMDS_MeshNode * n56,

                                     const SMDS_MeshNode * n67,

                                     const SMDS_MeshNode * n78,

                                     const SMDS_MeshNode * n85,

                                     const SMDS_MeshNode * n15,

                                     const SMDS_MeshNode * n26,

                                     const SMDS_MeshNode * n37,

                                     const SMDS_MeshNode * n48,

                                     const SMDS_MeshNode * n1234,

                                     const SMDS_MeshNode * n1256,

                                     const SMDS_MeshNode * n2367,

                                     const SMDS_MeshNode * n3478,

                                     const SMDS_MeshNode * n1458,

                                     const SMDS_MeshNode * n5678,

                                     const SMDS_MeshNode * nCenter);


  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,

                                                 const smIdType               ID);


  virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,

                                                 const smIdType                                ID);


  virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);


  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,

                                                    const smIdType                ID);


  virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,

                                                    const smIdType                                 ID);


  virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);


  virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

    (const std::vector<smIdType>& nodes_ids,

     const std::vector<int>&      quantities,

     const smIdType               ID);


  virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

    (const std::vector<const SMDS_MeshNode*>& nodes,

     const std::vector<int>&                  quantities,

     const smIdType                           ID);


  virtual SMDS_MeshVolume* AddPolyhedralVolume

    (const std::vector<const SMDS_MeshNode*>& nodes,

     const std::vector<int>&                  quantities);


  virtual void MoveNode(const SMDS_MeshNode *, double x, double y, double z);

  virtual void RemoveNode(const SMDS_MeshNode *);

  void RemoveElement(const SMDS_MeshElement *);


  bool RemoveFreeNode   (const SMDS_MeshNode *,    SMESHDS_SubMesh *, bool fromGroups=true);

  void RemoveFreeElement(const SMDS_MeshElement *, SMESHDS_SubMesh *, bool fromGroups=true);


  void ClearMesh();


  bool ChangeElementNodes(const SMDS_MeshElement * elem,

                          const SMDS_MeshNode    * nodes[],

                          const int                nbnodes);

  bool ChangePolygonNodes(const SMDS_MeshElement *           elem,

                          std::vector<const SMDS_MeshNode*>& nodes);

  bool ChangePolyhedronNodes(const SMDS_MeshElement *                 elem,

                             const std::vector<const SMDS_MeshNode*>& nodes,

                             const std::vector<int>&                  quantities);

  bool ModifyCellNodes(vtkIdType smdsVolId, std::map<int,int> localClonedNodeIds);

  void Renumber (const bool isNodes, const smIdType startID=1, const smIdType deltaID=1);


  void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Shell & S);

  void SetNodeInVolume(const SMDS_MeshNode * aNode, const TopoDS_Solid & S);

  void SetNodeOnFace  (const SMDS_MeshNode * aNode, const TopoDS_Face& S, double u=0.,double v=0.);

  void SetNodeOnEdge  (const SMDS_MeshNode * aNode, const TopoDS_Edge& S, double u=0.);

  void SetNodeOnVertex(const SMDS_MeshNode * aNode, const TopoDS_Vertex & S);

  void UnSetNodeOnShape(const SMDS_MeshNode * aNode);

  void UnSetElementOnShape(const SMDS_MeshElement * anElt);

  void SetMeshElementOnShape  (const SMDS_MeshElement * anElt, const TopoDS_Shape & S);

  void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt, const TopoDS_Shape & S);

  void SetNodeInVolume(const SMDS_MeshNode * aNode, int Index);

  void SetNodeOnFace  (const SMDS_MeshNode * aNode, int Index, double u=0., double v=0.);

  void SetNodeOnEdge  (const SMDS_MeshNode * aNode, int Index, double u=0.);

  void SetNodeOnVertex(const SMDS_MeshNode * aNode, int Index);

  void SetMeshElementOnShape(const SMDS_MeshElement * anElt, int Index);

  bool HasMeshElements(const TopoDS_Shape & S) const;

  SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;

  SMESHDS_SubMesh * MeshElements(const int Index) const;

  std::list<int> SubMeshIndices() const;

  SMESHDS_SubMeshIteratorPtr SubMeshes() const;


  bool HasHypothesis(const TopoDS_Shape & S);

  const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;

  bool IsUsedHypothesis(const SMESHDS_Hypothesis * H) const;

  const ShapeToHypothesis & GetHypotheses() const { return myShapeToHypothesis; }


  SMESHDS_Script * GetScript();

  void ClearScript();


  int ShapeToIndex(const TopoDS_Shape & aShape) const;

  const TopoDS_Shape& IndexToShape(int ShapeIndex) const;

  int MaxShapeIndex() const { return myIndexToShape.Extent(); }

  int MaxSubMeshIndex() const;


  SMESHDS_SubMesh * NewSubMesh(int Index);

  int AddCompoundSubmesh(const TopoDS_Shape& S, TopAbs_ShapeEnum type = TopAbs_SHAPE);


  // Groups. SMESHDS_Mesh is not an owner of groups

  void AddGroup (SMESHDS_GroupBase* theGroup)      { myGroups.insert(theGroup); }

  void RemoveGroup (SMESHDS_GroupBase* theGroup)   { myGroups.erase(theGroup); }

  size_t GetNbGroups() const                      { return myGroups.size(); }

  const std::set<SMESHDS_GroupBase*>& GetGroups() const { return myGroups; }


  bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;


  virtual void CompactMesh();

  void CleanDownWardConnectivity();

  void BuildDownWardConnectivity(bool withEdges);


  virtual void SetStructuredGrid( const TopoDS_Shape & shape, const int nx, const int ny, const int nz = 1 );

  virtual void SetNodeOnStructuredGrid( const TopoDS_Shape & shape, const std::shared_ptr<gp_Pnt>& P, const int iIndex, const int jIndex, const int kIndex = 0 );

  virtual void SetNodeOnStructuredGrid( const TopoDS_Shape & shape, const SMDS_MeshNode* point, const int iIndex, const int jIndex, const int kIndex = 0 );

  virtual void SetNodeOnStructuredGrid( const TopoDS_Shape & shape, const SMDS_MeshNode* point, const int index );

  virtual bool HasStructuredGridFilled( const TopoDS_Shape & shape ) const;

  virtual bool HasSomeStructuredGridFilled() const;

  virtual const std::shared_ptr<SMESHUtils::SMESH_RegularGrid>& GetTheGrid( const TopoDS_Shape & shape );

  ~SMESHDS_Mesh();


 private:


  ShapeToHypothesis          myShapeToHypothesis;


  int                        myPersistentID;

  TopoDS_Shape               myShape;


  class SubMeshHolder;

  SubMeshHolder*             mySubMeshHolder;


  TopTools_IndexedMapOfShape myIndexToShape;


  typedef std::set<SMESHDS_GroupBase*> TGroups;

  TGroups                    myGroups;


  SMESHDS_Script*            myScript;

  bool                       myIsEmbeddedMode;


  int add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );

  SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);


  // Index the regular grid associated to the mesh in the geometry index

  NCollection_DataMap<int,std::shared_ptr<SMESHUtils::SMESH_RegularGrid>> myRegularGrid;

};


#endif

SMDS_Mesh.hxx

ShapeToHypothesis
NCollection_DataMap< TopoDS_Shape, THypList, SMESHDS_Hasher > ShapeToHypothesis
Definition: SMESHDS_Mesh.hxx:92

THypList
std::list< const SMESHDS_Hypothesis * > THypList
Definition: SMESHDS_Mesh.hxx:64

SMESHDS_SubMesh.hxx

SMESHDS_SubMeshIteratorPtr
boost::shared_ptr< SMESHDS_SubMeshIterator > SMESHDS_SubMeshIteratorPtr
Definition: SMESHDS_SubMesh.hxx:43

SMESH_RegularGrid.hxx

SMESH_SMESHDS.hxx

SMESHDS_EXPORT
#define SMESHDS_EXPORT
Definition: SMESH_SMESHDS.hxx:37

SMESH_Utils.hxx

DownIdType
Definition: SMDS_Downward.hxx:46

SMDS_BallElement
Ball element.
Definition: SMDS_BallElement.hxx:36

SMDS_Mesh0DElement
0D mesh element.
Definition: SMDS_Mesh0DElement.hxx:36

SMDS_MeshEdge
Edge mesh element.
Definition: SMDS_MeshEdge.hxx:36

SMDS_MeshElement
Base class for elements.
Definition: SMDS_MeshElement.hxx:56

SMDS_MeshFace
Mesh face.
Definition: SMDS_MeshFace.hxx:41

SMDS_MeshNode
Definition: SMDS_MeshNode.hxx:36

SMDS_MeshVolume
Mesh volume.
Definition: SMDS_MeshVolume.hxx:40

SMDS_Mesh
Definition: SMDS_Mesh.hxx:53

SMDS_Mesh::MoveNode
virtual void MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
Definition: SMDS_Mesh.cxx:985

SMDS_Mesh::ChangeElementNodes
bool ChangeElementNodes(const SMDS_MeshElement *elem, const SMDS_MeshNode *nodes[], const int nbnodes)
Definition: SMDS_Mesh.cxx:1116

SMDS_Mesh::AddBallWithID
virtual SMDS_BallElement * AddBallWithID(smIdType n, double diameter, smIdType ID)
create a Ball and add it to the current Mesh
Definition: SMDS_Mesh.cxx:248

SMDS_Mesh::ChangePolyhedronNodes
bool ChangePolyhedronNodes(const SMDS_MeshElement *elem, const std::vector< const SMDS_MeshNode * > &nodes, const std::vector< int > &quantities)
Definition: SMDS_Mesh.cxx:1080

SMDS_Mesh::Add0DElementWithID
virtual SMDS_Mesh0DElement * Add0DElementWithID(smIdType n, smIdType ID)
create a Mesh0DElement and add it to the current Mesh
Definition: SMDS_Mesh.cxx:205

SMDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID)
Add a triangle defined by its nodes IDs.
Definition: SMDS_Mesh.cxx:351

SMDS_Mesh::RemoveNode
virtual void RemoveNode(const SMDS_MeshNode *node)
Remove a node and all the elements which own this node.
Definition: SMDS_Mesh.cxx:1016

SMDS_Mesh::RemoveElement
virtual void RemoveElement(const SMDS_MeshElement *elem, std::vector< const SMDS_MeshElement * > &removedElems, std::vector< const SMDS_MeshElement * > &removedNodes, const bool removenodes=false)
Definition: SMDS_Mesh.cxx:1855

SMDS_Mesh::AddPolygonalFaceWithID
virtual SMDS_MeshFace * AddPolygonalFaceWithID(const std::vector< smIdType > &nodes_ids, const smIdType ID)
Add a polygon defined by its nodes IDs.
Definition: SMDS_Mesh.cxx:816

SMDS_Mesh::AddPolygonalFace
virtual SMDS_MeshFace * AddPolygonalFace(const std::vector< const SMDS_MeshNode * > &nodes)
Add a polygon defined by its nodes.
Definition: SMDS_Mesh.cxx:854

SMDS_Mesh::AddNodeWithID
virtual SMDS_MeshNode * AddNodeWithID(double x, double y, double z, smIdType ID)
create a MeshNode and add it to the current Mesh
Definition: SMDS_Mesh.cxx:187

SMDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
Create a new tetrahedron and add it to the mesh.
Definition: SMDS_Mesh.cxx:458

SMDS_Mesh::AddPolyhedralVolume
virtual SMDS_MeshVolume * AddPolyhedralVolume(const std::vector< const SMDS_MeshNode * > &nodes, const std::vector< int > &quantities)
Create a new polyhedral volume and add it to the mesh.
Definition: SMDS_Mesh.cxx:955

SMDS_Mesh::AddBall
virtual SMDS_BallElement * AddBall(const SMDS_MeshNode *n, double diameter)
create a Ball and add it to the current Mesh
Definition: SMDS_Mesh.cxx:259

SMDS_Mesh::AddQuadPolygonalFaceWithID
virtual SMDS_MeshFace * AddQuadPolygonalFaceWithID(const std::vector< smIdType > &nodes_ids, const smIdType ID)
Add a quadratic polygon defined by its nodes IDs.
Definition: SMDS_Mesh.cxx:863

SMDS_Mesh::AddQuadPolygonalFace
virtual SMDS_MeshFace * AddQuadPolygonalFace(const std::vector< const SMDS_MeshNode * > &nodes)
Add a quadratic polygon defined by its nodes.
Definition: SMDS_Mesh.cxx:899

SMDS_Mesh::CompactMesh
virtual void CompactMesh()
Definition: SMDS_Mesh.cxx:2997

SMDS_Mesh::AddFace
virtual SMDS_MeshFace * AddFace(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3)
Add a triangle defined by its nodes.
Definition: SMDS_Mesh.cxx:340

SMDS_Mesh::AddPolyhedralVolumeWithID
virtual SMDS_MeshVolume * AddPolyhedralVolumeWithID(const std::vector< smIdType > &nodes_ids, const std::vector< int > &quantities, const smIdType ID)
Create a new polyhedral volume and add it to the mesh.
Definition: SMDS_Mesh.cxx:911

SMDS_Mesh::AddEdgeWithID
virtual SMDS_MeshEdge * AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID)
create a MeshEdge and add it to the current Mesh
Definition: SMDS_Mesh.cxx:292

SMDS_Mesh::AddNode
virtual SMDS_MeshNode * AddNode(double x, double y, double z)
create a MeshNode and add it to the current Mesh An ID is automatically assigned to the node.
Definition: SMDS_Mesh.cxx:177

SMDS_Mesh::AddEdge
virtual SMDS_MeshEdge * AddEdge(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2)
create a MeshEdge and add it to the current Mesh
Definition: SMDS_Mesh.cxx:305

SMDS_Mesh::RemoveFreeElement
virtual void RemoveFreeElement(const SMDS_MeshElement *elem)
Remove only the given element and only if it is free.
Definition: SMDS_Mesh.cxx:1952

SMDS_Mesh::AddVolume
virtual SMDS_MeshVolume * AddVolume(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4)
Create a new tetrahedron and add it to the mesh.
Definition: SMDS_Mesh.cxx:443

SMDS_Mesh::Add0DElement
virtual SMDS_Mesh0DElement * Add0DElement(const SMDS_MeshNode *n)
create a Mesh0DElement and add it to the current Mesh
Definition: SMDS_Mesh.cxx:216

SMESHDS_GroupBase
Definition: SMESHDS_GroupBase.hxx:42

SMESHDS_Hypothesis
Definition: SMESHDS_Hypothesis.hxx:37

SMESHDS_Mesh::SubMeshHolder
Definition: SMESHDS_Mesh.cxx:56

SMESHDS_Mesh
Definition: SMESHDS_Mesh.hxx:98

SMESHDS_Mesh::myRegularGrid
NCollection_DataMap< int, std::shared_ptr< SMESHUtils::SMESH_RegularGrid > > myRegularGrid
Definition: SMESHDS_Mesh.hxx:715

SMESHDS_Mesh::GetGroups
const std::set< SMESHDS_GroupBase * > & GetGroups() const
Definition: SMESHDS_Mesh.hxx:676

SMESHDS_Mesh::myShapeToHypothesis
ShapeToHypothesis myShapeToHypothesis
Definition: SMESHDS_Mesh.hxx:695

SMESHDS_Mesh::RemoveGroup
void RemoveGroup(SMESHDS_GroupBase *theGroup)
Definition: SMESHDS_Mesh.hxx:674

SMESHDS_Mesh::TGroups
std::set< SMESHDS_GroupBase * > TGroups
Definition: SMESHDS_Mesh.hxx:705

SMESHDS_Mesh::myPersistentID
int myPersistentID
Definition: SMESHDS_Mesh.hxx:697

SMESHDS_Mesh::myGroups
TGroups myGroups
Definition: SMESHDS_Mesh.hxx:706

SMESHDS_Mesh::myShape
TopoDS_Shape myShape
Definition: SMESHDS_Mesh.hxx:698

SMESHDS_Mesh::mySubMeshHolder
SubMeshHolder * mySubMeshHolder
Definition: SMESHDS_Mesh.hxx:701

SMESHDS_Mesh::GetHypotheses
const ShapeToHypothesis & GetHypotheses() const
Definition: SMESHDS_Mesh.hxx:659

SMESHDS_Mesh::MaxShapeIndex
int MaxShapeIndex() const
Definition: SMESHDS_Mesh.hxx:666

SMESHDS_Mesh::myIsEmbeddedMode
bool myIsEmbeddedMode
Definition: SMESHDS_Mesh.hxx:709

SMESHDS_Mesh::myScript
SMESHDS_Script * myScript
Definition: SMESHDS_Mesh.hxx:708

SMESHDS_Mesh::GetNbGroups
size_t GetNbGroups() const
Definition: SMESHDS_Mesh.hxx:675

SMESHDS_Mesh::AddGroup
void AddGroup(SMESHDS_GroupBase *theGroup)
Definition: SMESHDS_Mesh.hxx:673

SMESHDS_Mesh::myIndexToShape
TopTools_IndexedMapOfShape myIndexToShape
Definition: SMESHDS_Mesh.hxx:703

SMESHDS_Script
Definition: SMESHDS_Script.hxx:41

SMESHDS_SubMesh
Definition: SMESHDS_SubMesh.hxx:48

SMESHDS_Hasher
Definition: SMESHDS_DataMapOfShape.hxx:36

SMESHDS_Hasher::IsEqual
static Standard_Boolean IsEqual(const TopoDS_Shape &S1, const TopoDS_Shape &S2)
Definition: SMESHDS_Mesh.hxx:69

SMESHDS_Hasher::HashCode
static Standard_Integer HashCode(const TopoDS_Shape &S, const Standard_Integer Upper)
Definition: SMESHDS_Mesh.hxx:74