smesh/html/SMESHDS__Mesh_8hxx_source.html

 //  Copyright (C) 2007-2008  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

 //

 //  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 "SMDS_MeshNode.hxx"

 #include "SMDS_Mesh0DElement.hxx"

 #include "SMDS_MeshEdge.hxx"

 #include "SMDS_MeshFace.hxx"

 #include "SMDS_MeshVolume.hxx"

 #include "SMESHDS_Hypothesis.hxx"

 #include "SMESHDS_SubMesh.hxx"

 #include "SMESHDS_Script.hxx"


 #include <TopTools_IndexedMapOfShape.hxx>

 #include <TopoDS_Shape.hxx>

 #include <TopoDS_Solid.hxx>

 #include <TopoDS_Shell.hxx>

 #include <TopoDS_Face.hxx>

 #include <TopoDS_Vertex.hxx>

 #include <TopoDS_Edge.hxx>


 #include <NCollection_DataMap.hxx>

 #include <map>

 /*

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

  * So this functionality implement on new NCollection_DataMap technology

  */

 #include "SMESHDS_DataMapOfShape.hxx"


 class SMESHDS_GroupBase;


 class SMESHDS_EXPORT SMESHDS_Mesh:public SMDS_Mesh{

 public:

   SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode);

   bool IsEmbeddedMode();


   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, int ID);

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


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

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

   virtual SMDS_Mesh0DElement* Add0DElement      (const SMDS_MeshNode * node);


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

   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                        const SMDS_MeshNode * n2,

                                        int 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(int n1, int n2, int n12, int ID);

   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,

                                        const SMDS_MeshNode * n2,

                                        const SMDS_MeshNode * n12,

                                        int ID);

   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,

                                  const SMDS_MeshNode * n2,

                                  const SMDS_MeshNode * n12);


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

   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                        const SMDS_MeshNode * n2,

                                        const SMDS_MeshNode * n3,

                                        int ID);

   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,

                                  const SMDS_MeshNode * n2,

                                  const SMDS_MeshNode * n3);


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

   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,

                                        const SMDS_MeshNode * n2,

                                        const SMDS_MeshNode * n3,

                                        const SMDS_MeshNode * n4,

                                        int 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(int n1, int n2, int n3,

                                        int n12,int n23,int n31, int 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,

                                        int 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);


   // 2d order quadrangle

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

                                        int n12,int n23,int n34,int n41, int 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,

                                        int 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);


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

   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,

                                            const SMDS_MeshNode * n2,

                                            const SMDS_MeshNode * n3,

                                            const SMDS_MeshNode * n4,

                                            int ID);

   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,

                                      const SMDS_MeshNode * n2,

                                      const SMDS_MeshNode * n3,

                                      const SMDS_MeshNode * n4);


   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int 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,

                                            int 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);


   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int 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,

                                            int 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);


   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int 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,

                                            int 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);


   // 2d order tetrahedron of 10 nodes

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

                                            int n12,int n23,int n31,

                                            int n14,int n24,int n34, int 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,

                                            int 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(int n1, int n2, int n3, int n4, int n5,

                                            int n12,int n23,int n34,int n41,

                                            int n15,int n25,int n35,int n45,

                                            int 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,

                                            int 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(int n1, int n2, int n3,

                                            int n4, int n5, int n6,

                                            int n12,int n23,int n31,

                                            int n45,int n56,int n64,

                                            int n14,int n25,int n36,

                                            int 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,

                                            int 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 Hexahedrons with 20 nodes

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

                                            int n5, int n6, int n7, int n8,

                                            int n12,int n23,int n34,int n41,

                                            int n56,int n67,int n78,int n85,

                                            int n15,int n26,int n37,int n48,

                                            int 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,

                                            int 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);


   virtual SMDS_MeshFace* AddPolygonalFaceWithID (std::vector<int> nodes_ids,

                                                  const int        ID);


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

                                                  const int                         ID);


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


   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

                            (std::vector<int> nodes_ids,

                             std::vector<int> quantities,

                             const int        ID);


   virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID

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

                             std::vector<int>                  quantities,

                             const int                         ID);


   virtual SMDS_MeshVolume* AddPolyhedralVolume

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

                             std::vector<int>                  quantities);


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

   virtual void RemoveNode(const SMDS_MeshNode *);

   void RemoveElement(const SMDS_MeshElement *);


   void 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,

                              std::vector<const SMDS_MeshNode*> nodes,

                              std::vector<int>                  quantities);

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


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

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

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

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

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

   void UnSetNodeOnShape(const SMDS_MeshNode * aNode);

   void SetMeshElementOnShape(const SMDS_MeshElement * anElt,

                              const TopoDS_Shape & S);

   void UnSetMeshElementOnShape(const SMDS_MeshElement * anElt,

                                const TopoDS_Shape & S);

   bool HasMeshElements(const TopoDS_Shape & S);

   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;

   SMESHDS_SubMesh * MeshElements(const int Index);

   std::list<int> SubMeshIndices();

   const std::map<int,SMESHDS_SubMesh*>& SubMeshes() const

   { return myShapeIndexToSubMesh; }


   bool HasHypothesis(const TopoDS_Shape & S);

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

   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(); }


   SMESHDS_SubMesh * NewSubMesh(int Index);

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

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

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

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

   void SetNodeOnVertex(SMDS_MeshNode * aNode, int Index);

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


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

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

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

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


   bool IsGroupOfSubShapes (const TopoDS_Shape& aSubShape) const;


   ~SMESHDS_Mesh();


 private:

   void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )

   {

     //Update or build submesh

     std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );

     if ( it == myShapeIndexToSubMesh.end() )

       it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh() )).first;

     it->second->AddNode( aNode ); // add aNode to submesh

     }


   /*int HashCode( const TopoDS_Shape& S, const Standard_Integer theUpper ) const

   {

       return S.HashCode(2147483647);

   }*/


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


   typedef NCollection_DataMap< TopoDS_Shape, THypList > ShapeToHypothesis;


   ShapeToHypothesis          myShapeToHypothesis;


   int                        myMeshID;

   TopoDS_Shape               myShape;


   typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;

   TShapeIndexToSubMesh myShapeIndexToSubMesh;


   TopTools_IndexedMapOfShape myIndexToShape;


   typedef std::set<SMESHDS_GroupBase*> TGroups;

   TGroups myGroups;


   SMESHDS_Script*            myScript;

   bool                       myIsEmbeddedMode;


   // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:

   // avoid search of submeshes in maps

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

   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);

   SMESHDS_SubMesh* getSubmesh( const int            Index );

   int                        myCurSubID;

   TopoDS_Shape               myCurSubShape;

   SMESHDS_SubMesh*           myCurSubMesh;

 };


 #endif

SMDS_Mesh0DElement.hxx

SMDS_MeshEdge.hxx

SMDS_MeshFace.hxx

SMDS_MeshNode.hxx

SMDS_MeshVolume.hxx

SMDS_Mesh.hxx

SMESHDS_DataMapOfShape.hxx

SMESHDS_Hypothesis.hxx

SMESHDS_Script.hxx

SMESHDS_SubMesh.hxx

SMESH_SMESHDS.hxx

SMESHDS_EXPORT
#define SMESHDS_EXPORT
Definition: SMESH_SMESHDS.hxx:36

SMDS_Mesh0DElement
Definition: SMDS_Mesh0DElement.hxx:36

SMDS_MeshEdge
Definition: SMDS_MeshEdge.hxx:35

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

SMDS_MeshFace
Definition: SMDS_MeshFace.hxx:34

SMDS_MeshNode
Definition: SMDS_MeshNode.hxx:36

SMDS_MeshVolume
Definition: SMDS_MeshVolume.hxx:34

SMDS_Mesh
Definition: SMDS_Mesh.hxx:45

SMESHDS_GroupBase
Definition: SMESHDS_GroupBase.hxx:41

SMESHDS_Hypothesis
Definition: SMESHDS_Hypothesis.hxx:37

SMESHDS_Mesh
Definition: SMESHDS_Mesh.hxx:59

SMESHDS_Mesh::AddEdge
virtual SMDS_MeshEdge * AddEdge(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n12)

SMESHDS_Mesh::myShapeIndexToSubMesh
TShapeIndexToSubMesh myShapeIndexToSubMesh
Definition: SMESHDS_Mesh.hxx:468

SMESHDS_Mesh::AddVolume
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)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n12, int n23, int n31, int n14, int n24, int n34, int ID)

SMESHDS_Mesh::UnSetNodeOnShape
void UnSetNodeOnShape(const SMDS_MeshNode *aNode)

SMESHDS_Mesh::AddVolume
virtual SMDS_MeshVolume * AddVolume(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4)

SMESHDS_Mesh::TShapeIndexToSubMesh
std::map< int, SMESHDS_SubMesh * > TShapeIndexToSubMesh
Definition: SMESHDS_Mesh.hxx:467

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(int n1, int n2, int n3, int n4, int ID)

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

SMESHDS_Mesh::myShapeToHypothesis
ShapeToHypothesis myShapeToHypothesis
Definition: SMESHDS_Mesh.hxx:462

SMESHDS_Mesh::myMeshID
int myMeshID
Definition: SMESHDS_Mesh.hxx:464

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

SMESHDS_Mesh::AddFace
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)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n12, int n23, int n31, int n45, int n56, int n64, int n14, int n25, int n36, int ID)

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

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, int ID)

SMESHDS_Mesh::AddNode
virtual SMDS_MeshNode * AddNode(double x, double y, double z)

SMESHDS_Mesh::GetScript
SMESHDS_Script * GetScript()

SMESHDS_Mesh::AddFace
virtual SMDS_MeshFace * AddFace(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3)

SMESHDS_Mesh::AddVolume
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)

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

SMESHDS_Mesh::HasMeshElements
bool HasMeshElements(const TopoDS_Shape &S)

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

SMESHDS_Mesh::MoveNode
void MoveNode(const SMDS_MeshNode *, double x, double y, double z)

SMESHDS_Mesh::AddEdgeWithID
virtual SMDS_MeshEdge * AddEdgeWithID(int n1, int n2, int n12, int ID)

SMESHDS_Mesh::getSubmesh
SMESHDS_SubMesh * getSubmesh(const TopoDS_Shape &shape)

SMESHDS_Mesh::IsGroupOfSubShapes
bool IsGroupOfSubShapes(const TopoDS_Shape &aSubShape) const

SMESHDS_Mesh::AddEdgeWithID
virtual SMDS_MeshEdge * AddEdgeWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n12, int ID)

SMESHDS_Mesh::MeshElements
SMESHDS_SubMesh * MeshElements(const int Index)

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(int n1, int n2, int n3, int n4, int n12, int n23, int n34, int n41, int ID)

SMESHDS_Mesh::SMESHDS_Mesh
SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode)

SMESHDS_Mesh::AddFace
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)

SMESHDS_Mesh::RemoveFreeNode
void RemoveFreeNode(const SMDS_MeshNode *, SMESHDS_SubMesh *, bool fromGroups=true)

SMESHDS_Mesh::AddPolyhedralVolume
virtual SMDS_MeshVolume * AddPolyhedralVolume(std::vector< const SMDS_MeshNode * > nodes, std::vector< int > quantities)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n12, int n23, int n34, int n41, int n56, int n67, int n78, int n85, int n15, int n26, int n37, int n48, int ID)

SMESHDS_Mesh::GetNbGroups
int GetNbGroups() const
Definition: SMESHDS_Mesh.hxx:436

SMESHDS_Mesh::ClearMesh
void ClearMesh()

SMESHDS_Mesh::SetMeshElementOnShape
void SetMeshElementOnShape(const SMDS_MeshElement *anElt, int Index)

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

SMESHDS_Mesh::AddFaceWithID
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, int ID)

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

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

SMESHDS_Mesh::AddPolygonalFaceWithID
virtual SMDS_MeshFace * AddPolygonalFaceWithID(std::vector< const SMDS_MeshNode * > nodes, const int ID)

SMESHDS_Mesh::AddVolume
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)

SMESHDS_Mesh::~SMESHDS_Mesh
~SMESHDS_Mesh()

SMESHDS_Mesh::NewSubMesh
SMESHDS_SubMesh * NewSubMesh(int Index)

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

SMESHDS_Mesh::RemoveElement
void RemoveElement(const SMDS_MeshElement *)

SMESHDS_Mesh::myCurSubMesh
SMESHDS_SubMesh * myCurSubMesh
Definition: SMESHDS_Mesh.hxx:485

SMESHDS_Mesh::myGroups
TGroups myGroups
Definition: SMESHDS_Mesh.hxx:473

SMESHDS_Mesh::add
bool add(const SMDS_MeshElement *elem, SMESHDS_SubMesh *subMesh)

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

SMESHDS_Mesh::IndexToShape
const TopoDS_Shape & IndexToShape(int ShapeIndex) const

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(int n1, int n2, int n3, int n12, int n23, int n31, int ID)

SMESHDS_Mesh::ChangePolygonNodes
bool ChangePolygonNodes(const SMDS_MeshElement *elem, std::vector< const SMDS_MeshNode * > nodes)

SMESHDS_Mesh::myCurSubShape
TopoDS_Shape myCurSubShape
Definition: SMESHDS_Mesh.hxx:484

SMESHDS_Mesh::addNodeToSubmesh
void addNodeToSubmesh(const SMDS_MeshNode *aNode, int Index)
Definition: SMESHDS_Mesh.hxx:444

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

SMESHDS_Mesh::myShape
TopoDS_Shape myShape
Definition: SMESHDS_Mesh.hxx:465

SMESHDS_Mesh::ChangeElementNodes
bool ChangeElementNodes(const SMDS_MeshElement *elem, const SMDS_MeshNode *nodes[], const int nbnodes)

SMESHDS_Mesh::AddPolyhedralVolumeWithID
virtual SMDS_MeshVolume * AddPolyhedralVolumeWithID(std::vector< const SMDS_MeshNode * > nodes, std::vector< int > quantities, const int ID)

SMESHDS_Mesh::AddPolygonalFaceWithID
virtual SMDS_MeshFace * AddPolygonalFaceWithID(std::vector< int > nodes_ids, const int ID)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)

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

SMESHDS_Mesh::AddFaceWithID
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, int ID)

SMESHDS_Mesh::AddPolyhedralVolumeWithID
virtual SMDS_MeshVolume * AddPolyhedralVolumeWithID(std::vector< int > nodes_ids, std::vector< int > quantities, const int ID)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const SMDS_MeshNode *n5, int ID)

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

SMESHDS_Mesh::Renumber
void Renumber(const bool isNodes, const int startID=1, const int deltaID=1)

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(int n1, int n2, int n3, int ID)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)

SMESHDS_Mesh::AddEdge
virtual SMDS_MeshEdge * AddEdge(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2)

SMESHDS_Mesh::SubMeshes
const std::map< int, SMESHDS_SubMesh * > & SubMeshes() const
Definition: SMESHDS_Mesh.hxx:415

SMESHDS_Mesh::IsEmbeddedMode
bool IsEmbeddedMode()

SMESHDS_Mesh::HasHypothesis
bool HasHypothesis(const TopoDS_Shape &S)

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

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)

SMESHDS_Mesh::MeshElements
SMESHDS_SubMesh * MeshElements(const TopoDS_Shape &S) const

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

SMESHDS_Mesh::AddEdgeWithID
virtual SMDS_MeshEdge * AddEdgeWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, int ID)

SMESHDS_Mesh::AddVolume
virtual SMDS_MeshVolume * AddVolume(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, const SMDS_MeshNode *n5)

SMESHDS_Mesh::SetNodeInVolume
void SetNodeInVolume(const SMDS_MeshNode *aNode, int Index)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID)

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

SMESHDS_Mesh::AddNodeWithID
virtual SMDS_MeshNode * AddNodeWithID(double x, double y, double z, int ID)

SMESHDS_Mesh::AddVolume
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)

SMESHDS_Mesh::SubMeshIndices
std::list< int > SubMeshIndices()

SMESHDS_Mesh::ShapeToMesh
TopoDS_Shape ShapeToMesh() const

SMESHDS_Mesh::ChangePolyhedronNodes
bool ChangePolyhedronNodes(const SMDS_MeshElement *elem, std::vector< const SMDS_MeshNode * > nodes, std::vector< int > quantities)

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

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

SMESHDS_Mesh::Add0DElement
virtual SMDS_Mesh0DElement * Add0DElement(const SMDS_MeshNode *node)

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4, int ID)

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

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

SMESHDS_Mesh::AddVolumeWithID
virtual SMDS_MeshVolume * AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n12, int n23, int n34, int n41, int n15, int n25, int n35, int n45, int ID)

SMESHDS_Mesh::ClearScript
void ClearScript()

SMESHDS_Mesh::Add0DElementWithID
virtual SMDS_Mesh0DElement * Add0DElementWithID(int nodeID, int ID)

SMESHDS_Mesh::myIsEmbeddedMode
bool myIsEmbeddedMode
Definition: SMESHDS_Mesh.hxx:476

SMESHDS_Mesh::AddEdgeWithID
virtual SMDS_MeshEdge * AddEdgeWithID(int n1, int n2, int ID)

SMESHDS_Mesh::AddVolume
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)

SMESHDS_Mesh::ShapeToIndex
int ShapeToIndex(const TopoDS_Shape &aShape) const

SMESHDS_Mesh::RemoveNode
virtual void RemoveNode(const SMDS_MeshNode *)

SMESHDS_Mesh::getSubmesh
SMESHDS_SubMesh * getSubmesh(const int Index)

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

SMESHDS_Mesh::AddFaceWithID
virtual SMDS_MeshFace * AddFaceWithID(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, int ID)

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

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

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

SMESHDS_Mesh::AddVolume
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)

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

SMESHDS_Mesh::myIndexToShape
TopTools_IndexedMapOfShape myIndexToShape
Definition: SMESHDS_Mesh.hxx:470

SMESHDS_Mesh::Add0DElementWithID
virtual SMDS_Mesh0DElement * Add0DElementWithID(const SMDS_MeshNode *node, int ID)

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

SMESHDS_Mesh::SetNodeOnEdge
void SetNodeOnEdge(SMDS_MeshNode *aNode, int Index, double u=0.)

SMESHDS_Mesh::myCurSubID
int myCurSubID
Definition: SMESHDS_Mesh.hxx:483

SMESHDS_Mesh::SetNodeOnVertex
void SetNodeOnVertex(SMDS_MeshNode *aNode, int Index)

SMESHDS_Mesh::AddFace
virtual SMDS_MeshFace * AddFace(const SMDS_MeshNode *n1, const SMDS_MeshNode *n2, const SMDS_MeshNode *n3, const SMDS_MeshNode *n4)

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

SMESHDS_Mesh::ShapeToMesh
void ShapeToMesh(const TopoDS_Shape &S)

SMESHDS_Mesh::AddVolumeWithID
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, int ID)

SMESHDS_Script
Definition: SMESHDS_Script.hxx:38

SMESHDS_SubMesh
Definition: SMESHDS_SubMesh.hxx:39